ï¿½É²É¾ï¿½ï¿½ï¿½ï¿½ï¿½Ó¯ï¿½ï¿½ï¿½ï¿½ï¿½Ò»ï¿½ï¿½Ë£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ð¡ï¿½ï¿½ï¿½Ë´ï¿½ï¿½Í£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Pï¿½ï¿½ï¿½Ò¹ï¿½ï¿½Ã±Ë½ï¿½ï¿½Î¬ï¿½Ô²ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ë¸ß¸Ô£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Æ¡ï¿½ï¿½Ò¹ï¿½ï¿½Ã±ï¿½ï¿½ï¿½ï¿½ï¿½Î¬ï¿½Ô²ï¿½ï¿½ï¿½Ë¡ï¿½ï¿½ï¿½Ë³^ï¿½Ó£ï¿½ï¿½ï¿½ï¿½ï¿½ï¿½Ó¡ï¿½ ï¿½ï¿½ï¿½Í¯jï¿½Ó£ï¿½ï¿½Æºï¿½ï¿½ï¿½Ó£ï¿½ ? PNG ?%k25u25%fgd5n!? PNG ?%k25u25%fgd5n!? PNG ?%k25u25%fgd5n!? PNG ?%k25u25%fgd5n!PKr1]3,Ïxexe=python/libstdcxx/v6/__pycache__/printers.cpython-36.opt-1.pycnu„[µü¤3 À¡hõµã@säddlZddlZddlZddlZddlZddlZejddkrXeZe Z eZe ZejjZn6Gdd„dƒZddlm Z mZGdd„dejƒZeƒZdayddlZWnek r¶d aYnXd ayddlZeejd ƒrÖdaWnek rìYnXeedƒrejZneZdd „Zdadd„Zdd„Z dd„Z!dd„Z"dd„Z#dd„Z$dd„Z%dd„Z&Gdd „d eƒZ'Gd!d"„d"eƒZ(d#d$„Z)d%d&„Z*d'd(„Z+Gd)d*„d*eƒZ,d+d,„Z-d-d.„Z.Gd/d0„d0eƒZ/Gd1d2„d2eƒZ0Gd3d4„d4e0ƒZ1Gd5d6„d6e0ƒZ2Gd7d8„d8eƒZ3Gd9d:„d:eƒZ4Gd;d<„d„d>eƒZ6Gd?d@„d@eƒZ7GdAdB„dBeƒZ8GdCdD„dDeƒZ9GdEdF„dFeƒZ:GdGdH„dHeƒZ;dIdJ„ZdOdP„Z?GdQdR„dReƒZ@GdSdT„dTeƒZAGdUdV„dVeƒZBGdWdX„dXeƒZCGdYdZ„dZeƒZDGd[d\„d\eƒZEd]d^„ZFGd_d`„d`eƒZGGdadb„dbeƒZHGdcdd„ddeƒZIGdedf„dfeƒZJGdgdh„dheƒZKGdidj„djeƒZLGdkdl„dleƒZMGdmdn„dneƒZNdodp„ZOGdqdr„dreNƒZPGdsdt„dteNƒZQGdudv„dveNƒZRGdwdx„dxeNƒZSGdydz„dzeƒZTGd{d|„d|eƒZUGd}d~„d~eƒZVGdd€„d€eƒZWGdd‚„d‚eƒZXGdƒd„„d„eƒZYGd…d†„d†eƒZZGd‡dˆ„dˆeƒZ[Gd‰dŠ„dŠeƒZ\Gd‹dŒ„dŒeƒZ]GddŽ„dŽeƒZ^Gdd„deƒZ_Gd‘d’„d’eƒZ`Gd“d”„d”eƒZadd•d–d—d˜d™dšd›dœddždŸd g Zbd¡d¢d£d¤d¥d¦d§d¡gZcGd¨d©„d©eƒZdGdªd«„d«eƒZeGd¬d„deƒZfGd®d¯„d¯eƒZgGd°d±„d±eƒZhGd²d³„d³eƒZiGd´dµ„dµeƒZjGd¶d·„d·eƒZkGd¸d¹„d¹eƒZlGdºd»„d»eƒZmdanGd¼d½„d½eƒZod¾d¿„ZpGdÀdÁ„dÁeƒZqdÊdÂdÃ„ZrdÄdÅ„ZsdÆdÇ„ZtdÈdÉ„Zueuƒ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: cCs|jƒS)N)Ú__next__)Úself©rú0/usr/share/gcc-8/python/libstdcxx/v6/printers.pyÚnext?sz Iterator.nextN)Ú__name__Ú __module__Ú__qualname__Ú__doc__rrrrrr4s r)ÚimapÚizipc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚUTCz5Concrete tzinfo class representing the UTC time zone.cCs tjdƒS)Nr)ÚdatetimeÚ timedelta)rÚdtrrrÚ utcoffsetIsz UTC.utcoffsetcCsdS)Nrr)rrrrrÚtznameLsz UTC.tznamecCs tjdƒS)Nr)rr)rrrrrÚdstOszUTC.dstN)r r rrrrrrrrrrFsrTFZTypePrinterÚValuePrintercCsz|jƒ}xld|j|f}y tj|ƒStk r6YnX|jƒ}t|ƒr^|djr^|dj}q t dt |ƒ|fƒ‚q WdS)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_typens r%z__8::cGsdj|djdd„|Dƒƒƒ}y tj|ƒStjk rŠ}zFt|krv|jddtdƒ}y tj|ƒStjk rtYnX|‚WYdd}~XnXdS)z8 Lookup template specialization templ. z{}<{}>z, cSsg|]}t|ƒ‘qSr)r!)Ú.0Úarrrú ˆsz%lookup_templ_spec..z::éN)ÚformatÚjoinrrÚerrorÚ_versioned_namespaceÚreplace)ZtemplÚargsÚtÚerrrÚlookup_templ_spec„s r2cCs¬d|krd|}yt|dƒ}Wn|jdƒ}YnX|jƒ}y t||ƒStjk r¦t|dƒr¢t|dddƒr¢|jdd d ƒ}y t||ƒStjk r YnXdSXdS)a» Lookup specialization of template nodename corresponding to containertype. nodename - The name of a class template, as a String containertype - The container, as a gdb.Type Return a gdb.Type for the corresponding specialization of nodename, or None if the type cannot be found. e.g. lookup_node_type('_List_node', gdb.lookup_type('std::list')) will return a gdb.Type for the type std::_List_node. z::zstd::Ú value_typerZstdzstd::__cxx1998zstd::__debugZ__gnu_debugz ::__cxx1998::r)N)r%Útemplate_argumentrr2rr,Úis_member_of_namespacer.)ÚnodenameZ containertypeÚvaltyperrrÚlookup_node_type™s& r8cGs@t|tjƒrt|ƒ}t|ƒ}x|D]}|j|dƒr"dSq"WdS)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. z::TF)Ú isinstancerÚTyper!Ústrip_versioned_namespaceÚ startswith)r#Z namespacesÚ namespacerrrr5¾s r5cCs2t|tjƒr|j}dt|f}tjd||ƒdk S)zø Test whether a type is a specialization of the named class template. The type can be specified as a string or a gdb.Type object. The template should be the name of a class template as a string, without any 'std' qualification. z(%s)?%sz ^std::%s<.*>$N)r9rr:rr-ÚreÚmatch)ÚxÚ template_namerrrÚis_specialization_ofÌsrBcCs|jtdƒS)NÚ)r.r-)Útypenamerrrr;Úsr;cCs<d}d}tjddkr&tj|||dƒStj|||ddSdS)zCRemove "fundamentals_vN" inline namespace from qualified type name.z&^std::experimental::fundamentals_v\d::zstd::experimental::rrr))ÚcountN)ÚsysÚversion_infor>Úsub)r#ÚpatternÚreplrrrÚstrip_fundts_namespaceßs rKcCsVt|ƒ}|jddƒ}d}x d D]}|j||d|ƒ}qW|d}|j|d|ƒ}|S) zARemove known inline namespaces from the canonical name of a type.zstd::__cxx11::zstd::zstd::experimental::Úfundamentals_v1Úfundamentals_v2z::zfilesystem::zv1::)rLrM)r;r.)Útype_strZexpt_nsZlfts_nsZfs_nsrrrÚstrip_inline_namespacesés rOc Cs:d}g}x,y|j|j|ƒƒWn |S|d7}q WdS)z-Return a type's template arguments as a list.rr)N)Úappendr4)Útype_objÚnÚ template_argsrrrÚget_template_arg_listõsrTc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚSmartPtrIteratorz@An iterator for smart pointer types with a single 'child' value.cCs ||_dS)N)Ú_val)rÚvalrrrÚ__init__szSmartPtrIterator.__init__cCs|S)Nr)rrrrÚ__iter__szSmartPtrIterator.__iter__cCs$|jdkrt‚d|j|_}d|fS)Nzget())rVÚ StopIteration)rrWrrrr s zSmartPtrIterator.__next__N)r r rrrXrYrrrrrrUsrUc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)ÚSharedPointerPrinterzP Print a shared_ptr, weak_ptr, atomic, or atomic. cCst|ƒ|_||_|d|_dS)NÚ_M_ptr)r;Ú _typenamerVÚ_pointer)rrDrWrrrrXs zSharedPointerPrinter.__init__cCs t|jƒS)N)rUr^)rrrrÚchildrenszSharedPointerPrinter.childrencCsR|jdkrD|jddd}||d}t|jdjdƒ}|j|ƒS|jddS)Nzstd::atomicZ_M_refcountZ_M_valÚ_M_irÚpointerZ_M_pi)r]rVr%rÚcast)rZptr_valZptr_typerrrÚ_get_refcountss z#SharedPointerPrinter._get_refcountscCspd}|jƒ}|jjjdƒ}tt|ƒƒ}|dkr`|d}|d}|dkrPd|}nd||df}d|j||fS) NÚemptyrZ_M_use_countZ _M_weak_countzexpired, weak count %dzuse count %d, weak count %dr)z%s<%s> (%s))rcrVrr4r;r!r])rÚstateZ refcountsÚtargZusecountZ weakcountrrrÚ to_string(s zSharedPointerPrinter.to_stringN)r r rrrXr_rcrgrrrrr[s r[cCs¤|jjƒ}|djs&tdt|jƒƒ‚|j|djƒ}|jjƒ}t|ƒdkr^tdt|jƒƒ‚|djdkrt|dS|djrŽ|j|djƒStdt|jƒƒ‚dS)zBReturn the tuple element stored in a _Tuple_impl base class.r)z-Unsupported implementation for std::tuple: %srÚ_M_head_implNéÿÿÿÿri)rrrr r!rbrr")rWÚbasesZ head_baserrrrÚ_tuple_impl_get9s rkcCshtt|jƒƒ}||krtdƒ‚|j|jjƒdjƒ}x*|dkr^|j|jjƒdjƒ}|d8}q6Wt|ƒS)z6Return the result of std::get(val) on a std::tuple.z0Out of range index for std::get on std::tuplerr))rrTrr rbrrk)rRrWZ tuple_sizeÚnoderrrÚ tuple_getQs rmcCsd|jjƒdjjƒ}t|dƒs(t|dƒr6|dd}n$t|dƒrJ|d}ntdt|ƒƒ‚td|ƒS)z4Return the result of val.get() on a std::unique_ptr.rZ__uniq_ptr_dataZ__uniq_ptr_implÚ_M_tÚtuplez-Unsupported implementation for unique_ptr: %s)rrrrBr r!rm)rWZ impl_typeZtuple_memberrrrÚunique_ptr_get_s rpc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚUniquePointerPrinterzPrint a unique_ptr.cCs ||_dS)N)rV)rrDrWrrrrXtszUniquePointerPrinter.__init__cCstt|jƒƒS)N)rUrprV)rrrrr_wszUniquePointerPrinter.childrencCs|jjjdƒ}djt|ƒƒS)Nrzstd::unique_ptr<{}>)rVrr4r*r!)rr0rrrrgzszUniquePointerPrinter.to_stringN)r r rrrXr_rgrrrrrqqsrqcCs|djj|jƒƒjƒS)z7Return the value held in a __gnu_cxx::__aligned_membuf.Ú _M_storage)ÚaddressrbraÚdereference)Zbufr7rrrÚget_value_from_aligned_membufsruc CsjyF|jjƒdj}|dkr"|dS|dkrD|jjdƒ}t|d|ƒSWnYnXtdt|jƒƒ‚dS)z-Return the value held in an _List_node<_Val>.r)Ú_M_datarrrz!Unsupported implementation for %sN)rrr"r4rur r!)rlÚmemberr7rrrÚget_value_from_list_node„srxc@s8eZdZdZGdd„deƒZdd„Zdd„Zdd „Zd S)ÚStdListPrinterzPrint a std::list.c@s$eZdZdd„Zdd„Zdd„ZdS)zStdListPrinter._iteratorcCs"||_|d|_|j|_d|_dS)NÚ_M_nextr)Ú _nodetypeÚ_basersÚ_headÚ_count)rÚnodetypeÚheadrrrrX˜s z!StdListPrinter._iterator.__init__cCs|S)Nr)rrrrrYžsz!StdListPrinter._iterator.__iter__cCsR|j|jkrt‚|jj|jƒjƒ}|d|_|j}|jd|_t|ƒ}d||fS)Nrzr)z[%d])r|r}rZrbr{rtr~rx)rÚeltrErWrrrr¡s z!StdListPrinter._iterator.__next__N)r r rrXrYrrrrrÚ _iterator—sr‚cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX«s zStdListPrinter.__init__cCs(td|jjƒjƒ}|j||jddƒS)NÚ _List_nodeÚ_M_implÚ_M_node)r8rVrrar‚)rrrrrr_¯szStdListPrinter.childrencCs0|jdd}|d|jkr&d|jSd|jS)Nr„r…rzzempty %sz%s)rVrsr])rZheadnoderrrrg³s zStdListPrinter.to_stringN) r r rrrr‚rXr_rgrrrrry”s ryc@seZdZdd„Zdd„ZdS)ÚNodeIteratorPrintercCs$||_||_||_t||jƒ|_dS)N)rVr]Ú _contnamer8rr{)rrDrWZcontnamer6rrrrX»szNodeIteratorPrinter.__init__cCs:|jdsd|jS|jdj|jjƒƒjƒ}tt|ƒƒS)Nr…z(non-dereferenceable iterator for std::%s)rVr‡rbr{rartr!rx)rrlrrrrgÁs zNodeIteratorPrinter.to_stringN)r r rrXrgrrrrr†ºsr†c@seZdZdZdd„ZdS)ÚStdListIteratorPrinterzPrint std::list::iterator.cCstj|||ddƒdS)NÚlistrƒ)r†rX)rrDrWrrrrXÌszStdListIteratorPrinter.__init__N)r r rrrXrrrrrˆÉsrˆc@seZdZdZdd„ZdS)ÚStdFwdListIteratorPrinterz"Print std::forward_list::iterator.cCstj|||ddƒdS)NÚforward_listÚ_Fwd_list_node)r†rX)rrDrWrrrrXÓsz"StdFwdListIteratorPrinter.__init__N)r r rrrXrrrrrŠÐsrŠc@s8eZdZdZGdd„deƒZdd„Zdd„Zdd „Zd S)ÚStdSlistPrinterzPrint a __gnu_cxx::slist.c@s$eZdZdd„Zdd„Zdd„ZdS)zStdSlistPrinter._iteratorcCs||_|dd|_d|_dS)NÚ_M_headrzr)r{r|r~)rrr€rrrrXÜsz"StdSlistPrinter._iterator.__init__cCs|S)Nr)rrrrrYász"StdSlistPrinter._iterator.__iter__cCsL|jdkrt‚|jj|jƒjƒ}|d|_|j}|jd|_d||dfS)Nrrzr)z[%d]rv)r|rZrbr{rtr~)rrrErrrräs z"StdSlistPrinter._iterator.__next__N)r r rrXrYrrrrrr‚Ûsr‚cCs ||_dS)N)rV)rrDrWrrrrXíszStdSlistPrinter.__init__cCs td|jjƒ}|j|jƒ|jƒS)Nz__gnu_cxx::_Slist_node)r8rVrr‚ra)rrrrrr_ðszStdSlistPrinter.childrencCs|jdddkrdSdS)NrŽrzrzempty __gnu_cxx::slistz__gnu_cxx::slist)rV)rrrrrgôszStdSlistPrinter.to_stringN) r r rrrr‚rXr_rgrrrrrØs rc@s eZdZdZdd„Zdd„ZdS)ÚStdSlistIteratorPrinterz!Print __gnu_cxx::slist::iterator.cCs ||_dS)N)rV)rrDrWrrrrXýsz StdSlistIteratorPrinter.__init__cCs<|jdsdStd|jjƒjƒ}t|jdj|ƒjƒdƒS)Nr…z1non-dereferenceable iterator for __gnu_cxx::slistz__gnu_cxx::_Slist_noderv)rVr8rrar!rbrt)rrrrrrgs z!StdSlistIteratorPrinter.to_stringN)r r rrrXrgrrrrrúsrc@s@eZdZdZGdd„deƒZdd„Zdd„Zdd „Zd d„Z dS) ÚStdVectorPrinterzPrint a std::vector.c@s$eZdZdd„Zdd„Zdd„ZdS)zStdVectorPrinter._iteratorcCs^||_|rH|d|_d|_|d|_|d|_|jjƒj}d|j|_n||_||_d|_ dS)NÚ_M_prÚ _M_offseté) Ú_bitvecÚ_itemÚ_soÚ_finishÚ_fortrÚsizeofÚ_isizer~)rÚstartÚfinishZbitvecÚityperrrrXs z#StdVectorPrinter._iterator.__init__cCs|S)Nr)rrrrrYsz#StdVectorPrinter._iterator.__iter__cCs¸|j}|jd|_|jr‚|j|jkr4|j|jkr4t‚t|jjƒd|j>@ƒ}|jd|_|j|j krv|jd|_d|_d||fS|j|jkr’t‚|jjƒ}|jd|_d||fSdS)Nr)rz[%d]) r~r”r•r—r–r˜rZÚboolrtrš)rrErrrrrs z#StdVectorPrinter._iterator.__next__N)r r rrXrYrrrrrr‚sr‚cCs*t|ƒ|_||_|jjdƒjtjk|_dS)Nr) r;r]rVrr4ÚcoderÚTYPE_CODE_BOOLÚ_is_bool)rrDrWrrrrX0s zStdVectorPrinter.__init__cCs$|j|jdd|jdd|jƒS)Nr„Ú_M_startÚ _M_finish)r‚rVr¡)rrrrr_6szStdVectorPrinter.childrenc CsÒ|jdd}|jdd}|jdd}|jr®|jddd}|jddd}|jddd}|jƒj}d|j}||||}|||}d|jt|ƒt|ƒfSd |jt||ƒt||ƒfSdS) Nr„r¢r£Z_M_end_of_storager‘r’r“z"%s of length %d, capacity %dz%s of length %d, capacity %d)rVr¡rtrr™r]Úint) rr›rœÚendZforZblÚlengthZcapacityrrrrg;s zStdVectorPrinter.to_stringcCsdS)NÚarrayr)rrrrÚdisplay_hintMszStdVectorPrinter.display_hintN) r r rrrr‚rXr_rgr¨rrrrrs%rc@s eZdZdZdd„Zdd„ZdS)ÚStdVectorIteratorPrinterzPrint std::vector::iterator.cCs ||_dS)N)rV)rrDrWrrrrXTsz!StdVectorIteratorPrinter.__init__cCs |jdsdSt|jdjƒƒS)NZ _M_currentz,non-dereferenceable iterator for std::vector)rVr!rt)rrrrrgWs z"StdVectorIteratorPrinter.to_stringN)r r rrrXrgrrrrr©Qsr©c@s eZdZdZdd„Zdd„ZdS)ÚStdBitIteratorPrinterz@Print std::vector's _Bit_iterator and _Bit_const_iterator.cCs ||_dS)N)rV)rrDrWrrrrX`szStdBitIteratorPrinter.__init__cCs.|jdsdSt|jdjƒd|jd>@ƒS)Nr‘z2non-dereferenceable iterator for std::vectorr)r’)rVržrt)rrrrrgcs zStdBitIteratorPrinter.to_stringN)r r rrrXrgrrrrrª]srªc@s eZdZdZdd„Zdd„ZdS)ÚStdBitReferencePrinterz#Print std::vector::reference.cCs ||_dS)N)rV)rrDrWrrrrXmszStdBitReferencePrinter.__init__cCs*|jdsdSt|jdjƒ|jd@ƒS)Nr‘z$invalid std::vector::referenceZ_M_mask)rVržrt)rrrrrgps z StdBitReferencePrinter.to_stringN)r r rrrXrgrrrrr«jsr«c@s8eZdZdZGdd„deƒZdd„Zdd„Zdd „Zd S)ÚStdTuplePrinterzPrint a std::tuple.c@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.)rrBrr )ÚnodesrrrÚ_is_nonempty_tuple}sz,StdTuplePrinter._iterator._is_nonempty_tuplecCs:||_|jjjƒ}|j|ƒr0|jj|djƒ|_d|_dS)Nr)r}rrr®rbr~)rr€rrrrrX‰s z"StdTuplePrinter._iterator.__init__cCs|S)Nr)rrrrrY”sz"StdTuplePrinter._iterator.__iter__cCsâ|js t‚|jjjƒ}t|ƒdkr&t‚t|ƒdkr:tdƒ‚t|ƒdkr`|jj|djƒ}d|_n&|jj|djƒ}|jj|djƒ|_|jd|_|jjƒ}t|ƒdks¶|djdkrÈd|jd|fSd|jd|dfSdS)Nrrz/Cannot parse more than 2 nodes in a tuple tree.r)rhz[%d]) r}rZrrrr rbr~r")rrÚimplrrrrr—s$ z"StdTuplePrinter._iterator.__next__N)r r rÚstaticmethodr®rXrYrrrrrr‚|sr‚cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrXÁs zStdTuplePrinter.__init__cCs|j|jƒS)N)r‚rV)rrrrr_ÅszStdTuplePrinter.childrencCs(t|jjjƒƒdkrd|jSd|jS)Nrzempty %sz %s containing)rrVrrr])rrrrrgÈs zStdTuplePrinter.to_stringN) r r rrrr‚rXr_rgrrrrr¬ys Er¬c@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)ÚStdStackOrQueuePrinterz!Print a std::stack or std::queue.cCst|ƒ|_tj|dƒ|_dS)NÚc)r;r]rÚdefault_visualizerÚ_visualizer)rrDrWrrrrXÑs zStdStackOrQueuePrinter.__init__cCs |jjƒS)N)r´r_)rrrrr_ÕszStdStackOrQueuePrinter.childrencCsd|j|jjƒfS)Nz%s wrapping: %s)r]r´rg)rrrrrgØsz StdStackOrQueuePrinter.to_stringcCst|jdƒr|jjƒSdS)Nr¨)Úhasattrr´r¨)rrrrr¨Üs z#StdStackOrQueuePrinter.display_hintN)r r rrrXr_rgr¨rrrrr±Îs 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)Nrnr„Z _M_node_countZ _M_headerÚ_M_leftr)Ú_sizeÚ_noder~)rZrbtreerrrrXèszRbtreeIterator.__init__cCs|S)Nr)rrrrrYíszRbtreeIterator.__iter__cCs t|jƒS)N)r¤r¸)rrrrÚ__len__ðszRbtreeIterator.__len__cCs¼|j|jkrt‚|j}|jd|_|j|jkr¸|j}|jƒdrl|jƒd}xd|jƒdrh|jƒd}qNWnF|jƒd}x$||jƒdkrœ|}|jƒd}qzW|jƒd|kr²|}||_|S)Nr)Z_M_rightr·Z _M_parent)r~r¸rZr¹rt)rÚresultrlÚparentrrrrós$zRbtreeIterator.__next__N)r r rrrXrYrºrrrrrr¶âs r¶c CsjyF|jjƒdj}|dkr"|dS|dkrD|jjdƒ}t|d|ƒSWnYnXtdt|jƒƒ‚dS)z0Return the value held in an _Rb_tree_node<_Val>.r)Z_M_value_fieldrrrz!Unsupported implementation for %sN)rrr"r4rur r!)rlrwr7rrrÚget_value_from_Rb_tree_node sr½c@s eZdZdZdd„Zdd„ZdS)ÚStdRbtreeIteratorPrinterz2Print std::map::iterator, std::set::iterator, etc.cCs"||_td|jjƒ}|jƒ|_dS)NÚ _Rb_tree_node)rVr8rraÚ _link_type)rrDrWrrrrrX!sz!StdRbtreeIteratorPrinter.__init__cCs0|jdsdS|jdj|jƒjƒ}tt|ƒƒS)Nr…z6non-dereferenceable iterator for associative container)rVrbrÀrtr!r½)rrlrrrrg&s z"StdRbtreeIteratorPrinter.to_stringN)r r rrrXrgrrrrr¾sr¾c@s eZdZdZdd„Zdd„ZdS)ÚStdDebugIteratorPrinterz-Print a debug enabled version of an iterator.cCs ||_dS)N)rV)rrDrWrrrrX0sz StdDebugIteratorPrinter.__init__cCsbtjdƒ}|jjjdƒ}|jj|ƒd}|std|ƒ|_nd|_dS)Nrir)) r;r]rVrr4Z_elttyper™r¤r×)rrDrWÚsizerrrrXãs 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_firstz %s with %s)rVr×r]rÃÚlong)rr›r¥Zdelta_nZdelta_sZdelta_erÚrrrrgíszStdDequePrinter.to_stringcCs@|jdd}|jdd}|j|d|d|d|d|jƒS)Nr„r¢r£r…rÜrÛ)rVrËr×)rr›r¥rrrr_ùszStdDequePrinter.childrencCsdS)Nr§r)rrrrr¨ÿszStdDequePrinter.display_hintN) r r rrrrËrXrgr_r¨rrrrrÓÂs rÓc@s eZdZdZdd„Zdd„ZdS)ÚStdDequeIteratorPrinterzPrint std::deque::iterator.cCs ||_dS)N)rV)rrDrWrrrrXsz StdDequeIteratorPrinter.__init__cCs |jdsdSt|jdjƒƒS)NrÜz+non-dereferenceable iterator for std::deque)rVr!rt)rrrrrg s z!StdDequeIteratorPrinter.to_stringN)r r rrrXrgrrrrrßsrßc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚStdStringPrinterz'Print a std::basic_string of some kind.cCs||_|jdƒdk|_dS)Nz::__cxx11::basic_stringr)ri)rVÚfindÚ_new_string)rrDrWrrrrXszStdStringPrinter.__init__cCsª|jj}|jtjkr|jƒ}|jdd}|jrL|jd}|j|jjƒƒ}n<|j ƒjƒ}tj t|ƒdƒjƒ}|j|ƒd}|j ƒd}t|dƒrž|j|dS|j|dS) NZ_M_dataplusr‘Z_M_string_lengthz::_Repr)Z _M_lengthÚlazy_string)r¦)rVrrŸrÚ TYPE_CODE_REFrÐrârbrÚunqualifiedrr!rartrµrãÚstring)rrÚptrr¦ZrealtypeZreptypeÚheaderrrrrgs zStdStringPrinter.to_stringcCsdS)Nrær)rrrrr¨-szStdStringPrinter.display_hintN)r r rrrXrgr¨rrrrràsràcCs"|d}|d}|d}|||fS)z'Access the streambuf put area pointers.Z _M_out_begZ _M_out_curZ _M_in_endr)Ú streambufÚpbaseÚpptrÚegptrrrrÚaccess_streambuf_ptrs1sríc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚStdStringBufPrinterzPrint a std::basic_stringbuf.cCs ||_dS)N)rV)rÚ_rWrrrrX<szStdStringBufPrinter.__init__cCsLt|jƒ\}}}|rB|s"||kr2|j||dS|j||dS|jdS)N)r¦Z _M_string)rírVræ)rrêrërìrrrrg?szStdStringBufPrinter.to_stringcCsdS)Nrær)rrrrr¨Isz StdStringBufPrinter.display_hintN)r r rrrXrgr¨rrrrrî9s rîc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚStdStringStreamPrinterz Print a std::basic_stringstream.cCsZ||_||_dd„|jjƒDƒd}tjd|j|ƒjƒtjdƒ|_ |j |djk|_ dS)NcSsg|]}|jr|j‘qSr)rr)r&Úfrrrr(Xsz3StdStringStreamPrinter.__init__..rZ__streamz$__stream->rdbuf()Ú_M_stringbuf)rVr]rrrZset_convenience_variablerbrsÚparse_and_evalÚ _streambufÚ_was_redirected)rrDrWZbasetyperrrrXPszStdStringStreamPrinter.__init__cCs$|jrd|j|jjƒfS|jdS)Nz%s redirected to %srò)rõr]rôrtrV)rrrrrg]sz StdStringStreamPrinter.to_stringcCs|jr dSdS)Nræ)rõ)rrrrr¨csz#StdStringStreamPrinter.display_hintN)r r rrrXrgr¨rrrrrðMs rðc@s$eZdZdd„Zdd„Zdd„ZdS)ÚTr1HashtableIteratorcCsj|d|_d|_|d|_t|jdƒjƒ|_d|_x2|j|jkrd|j|j|_|jrVP|jd|_q4WdS)NZ _M_bucketsrZ_M_bucket_countZ_Noder))Ú_bucketsÚ_bucketÚ _bucket_countr%rraÚ _node_typer¹)rÚ hashtablerrrrXjs zTr1HashtableIterator.__init__cCs|S)Nr)rrrrrYvszTr1HashtableIterator.__iter__cCs„|jdkrt‚|jj|jƒ}|jƒd}|jƒd|_|jdkr€|jd|_x2|j|jkr~|j|j|_|jrpP|jd|_qNW|S)NrZ_M_vrzr))r¹rZrbrúrtrørùr÷)rrlr»rrrrys zTr1HashtableIterator.__next__N)r r rrXrYrrrrrröisröc@s$eZdZdd„Zdd„Zdd„ZdS)ÚStdHashtableIteratorcCsR|dd|_|jjdƒ}|jjdƒjdƒ}tdt|ƒ|r>dndƒ}|jƒ|_dS) NZ_M_before_beginÚ_M_nxtr)é rzstd::__detail::_Hash_nodeÚtrueZfalse)r¹rr4r2r!rarú)rrûr7ÚcachedZ node_typerrrrXŠs zStdHashtableIterator.__init__cCs|S)Nr)rrrrrY’szStdHashtableIterator.__iter__cCsR|jdkrt‚|jj|jƒjƒ}|d|_|dj}|j|jjdƒjƒƒ}|jƒS)Nrrýrr) r¹rZrbrúrtrsrr4ra)rrÚvalptrrrrr•s zStdHashtableIterator.__next__N)r r rrXrYrrrrrrü‰srüc@s<eZdZdZdd„Zdd„Zdd„Zedd „ƒZd d„Z dS) ÚTr1UnorderedSetPrinterz1Print a std::unordered_set or tr1::unordered_set.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX¢s zTr1UnorderedSetPrinter.__init__cCs|jjdƒr|jS|jdS)Nzstd::tr1Ú_M_h)r]r<rV)rrrrÚ _hashtable¦sz!Tr1UnorderedSetPrinter._hashtablecCs|jƒd}d|jt|ƒfS)NÚ_M_element_countz %s with %s)rr]rÃ)rrErrrrg«sz Tr1UnorderedSetPrinter.to_stringcCsd|S)Nz[%d]r)ÚirrrÚ _format_count¯sz$Tr1UnorderedSetPrinter._format_countcCs@t|jtjƒƒ}|jjdƒr.t|t|jƒƒƒSt|t |jƒƒƒS)Nzstd::tr1) r rÚ itertoolsrEr]r<rrörrü)rÚcounterrrrr_³szTr1UnorderedSetPrinter.childrenN) r r rrrXrrgr°rr_rrrrrŸsrc@s\eZdZdZdd„Zdd„Zdd„Zedd „ƒZed d„ƒZ edd „ƒZ dd„Zdd„ZdS)ÚTr1UnorderedMapPrinterz1Print a std::unordered_map or tr1::unordered_map.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX½s zTr1UnorderedMapPrinter.__init__cCs|jjdƒr|jS|jdS)Nzstd::tr1r)r]r<rV)rrrrrÁsz!Tr1UnorderedMapPrinter._hashtablecCs|jƒd}d|jt|ƒfS)Nrz %s with %s)rr]rÃ)rrErrrrgÆsz Tr1UnorderedMapPrinter.to_stringccs&x |D]}x|D] }|VqWqWdS)Nr)r‰rrrrrÚ_flattenÊs zTr1UnorderedMapPrinter._flattencCs|d|dfS)NrÈrÉr)rrrrÚ_format_oneÐsz"Tr1UnorderedMapPrinter._format_onecCsd|S)Nz[%d]r)rrrrrÔsz$Tr1UnorderedMapPrinter._format_countcCsdt|jtjƒƒ}|jjdƒr@|jt|jt|j ƒƒƒƒ}t ||ƒS|jt|jt|j ƒƒƒƒ}t ||ƒS)Nzstd::tr1)r rrrEr]r<rrrörrrü)rr Údatarrrr_Øs zTr1UnorderedMapPrinter.childrencCsdS)NrÌr)rrrrr¨åsz#Tr1UnorderedMapPrinter.display_hintN) r r rrrXrrgr°rrrr_r¨rrrrr ºs r c@s8eZdZdZGdd„deƒZdd„Zdd„Zdd „Zd S)ÚStdForwardListPrinterzPrint a std::forward_list.c@s$eZdZdd„Zdd„Zdd„ZdS)zStdForwardListPrinter._iteratorcCs||_|d|_d|_dS)Nrzr)r{r|r~)rrr€rrrrXís z(StdForwardListPrinter._iterator.__init__cCs|S)Nr)rrrrrYòsz(StdForwardListPrinter._iterator.__iter__cCsl|jdkrt‚|jj|jƒjƒ}|d|_|j}|jd|_|dj}|j|jjdƒj ƒƒ}d||jƒfS)Nrrzr)rrz[%d]) r|rZrbr{rtr~rsrr4ra)rrrErrrrrõs z(StdForwardListPrinter._iterator.__next__N)r r rrXrYrrrrrr‚ìsr‚cCs||_t|ƒ|_dS)N)rVr;r])rrDrWrrrrXszStdForwardListPrinter.__init__cCs(td|jjƒjƒ}|j||jddƒS)NrŒr„rŽ)r8rVrrar‚)rrrrrr_szStdForwardListPrinter.childrencCs*|jddddkr d|jSd|jS)Nr„rŽrzrzempty %sz%s)rVr])rrrrrgs zStdForwardListPrinter.to_stringN) r r rrrr‚rXr_rgrrrrrés rc@sBeZdZdZd dd„Zdd„ZGdd„deƒZd d „Zdd„Z dS)ÚSingleObjContainerPrinterz8Base class for printers of containers of single objects.NcCs||_||_||_dS)N)Ú_contained_valuer´Ú_hint)rrWZvizZhintrrrrXsz"SingleObjContainerPrinter.__init__cCs(tst|ƒStjjtjjƒ|ƒp&t|ƒS)z5Return type as a string after applying type printers.)Ú_use_type_printingr!rÚtypesÚapply_type_recognizersÚget_type_recognizers)rrrrrÚ _recognizesz$SingleObjContainerPrinter._recognizec@s$eZdZdd„Zdd„Zdd„ZdS)z$SingleObjContainerPrinter._containedcCs ||_dS)N)rV)rrWrrrrXsz-SingleObjContainerPrinter._contained.__init__cCs|S)Nr)rrrrrY"sz-SingleObjContainerPrinter._contained.__iter__cCs"|jdkrt‚|j}d|_d|fS)Nz[contained value])rVrZ)rZretvalrrrr%s z-SingleObjContainerPrinter._contained.__next__N)r r rrXrYrrrrrÚ _containedsrcCs6|jdkr|jdƒSt|jdƒr*|jjƒS|j|jƒS)Nr_)rrrµr´r_)rrrrr_,s z"SingleObjContainerPrinter.childrencCs(t|jdƒr"t|jdƒr"|jjƒS|jS)Nr_r¨)rµr´r¨r)rrrrr¨3s z&SingleObjContainerPrinter.display_hint)N) r r rrrXrrrr_r¨rrrrrs rc CsH|jƒj}tjddkr"t|ƒ}nt|ƒ}ytj|ƒjj SdSdS)z{Find the name of the function referred to by the gdb.Value f, which should contain a function pointer from the program.rrN) rtrsrFrGrÞr¤rZblock_for_pcÚfunctionr")rñrrrÚfunction_pointer_to_name;s rcs4eZdZdZ‡fdd„Zdd„Zedd„ƒZ‡ZS)ÚStdExpAnyPrinterz+Print a std::any or std::experimental::any.csœt|ƒ|_t|jƒ|_||_d|_d}d}|jd}|dkr†t|ƒ}|sXtd|jƒ‚dj|ƒ}tj ||ƒ}|s€td|jƒ‚|j dƒ} d| kr g} xPtjƒD]D}y(tj d||j dƒƒ}| jtj|ƒƒWq¢tjk räYq¢Xq¢Wt| ƒdkrtd ƒ‚| d} n tj| ƒ} | jdƒ|_d}d | kr@|jddj}n(d | krZ|jdd}ntd|jƒ‚|j|jjƒƒjƒ}tj|ƒ}tt|ƒj||ƒdS)NZ _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 %sr)zstd::stringzstd::string(?!\w)z;Cannot uniquely determine std::string type used in std::anyz::_Manager_internalrrZ _M_bufferz::_Manager_externalr\)r;r]rKrVÚ_contained_typerr r*r>r?ÚgrouprÚ _string_typesrHrPrrr,rr4rsrbrartr³ÚsuperrX)rrDrWÚcontained_valueÚ visualizerZmgrÚfuncZrxÚmZmgrnameZmgrtypesÚsr@Zmgrtyper)Ú __class__rrrXVsX zStdExpAnyPrinter.__init__cCsT|jdkrd|jSd|j}t|jdƒr8||jjƒS|j|jƒ}|tt|ƒƒS)Nz%s [no contained value]z%s containing r_)rr]rµr´rgrr;r!)rÚdescr7rrrrgšs zStdExpAnyPrinter.to_stringcs@ttjdƒjƒƒh}d‰dddtg}|‡fdd„|DƒO}|S)Nzstd::stringzAbasic_string, std::allocator >zstd::zstd::__cxx11::csh|]}|ˆ’qSrr)r&Úq)r#rrú sz1StdExpAnyPrinter._string_types..)r!rrrr-)ZstringsZqualsr)r#rr£s zStdExpAnyPrinter._string_types) r r rrrXrgr°rÚ __classcell__rr)r$rrSsD rcs(eZdZdZ‡fdd„Zdd„Z‡ZS)ÚStdExpOptionalPrinterz5Print a std::optional or std::experimental::optional.c sŠt|ƒ|_t|jƒ|_|d}|jjdƒr8|d}|}n*|d}|d}y|d}WnYnXtj|ƒ}|std}tt|ƒj||ƒdS)NÚ _M_payloadzstd::experimentalÚ _M_engagedÚ_M_value) r;r]rKr<rr³rr)rX)rrDrWZpayloadZengagedrr )r$rrrX´s" zStdExpOptionalPrinter.__init__cCs:|jdkrd|jSt|jdƒr4d|j|jjƒfS|jS)Nz%s [no contained value]r_z%s containing %s)rr]rµr´rg)rrrrrgÉs zStdExpOptionalPrinter.to_string)r r rrrXrgr(rr)r$rr)±sr)cs(eZdZdZ‡fdd„Zdd„Z‡ZS)ÚStdVariantPrinterzPrint a std::variant.cs”t|jƒ}t|ƒ|_|d|_|jt|ƒkrz[%s])r•r—rZrtr~r7r@r=)rrÊrEr?r0rrrrRs z$StdExpPathPrinter._iterator.__next__N)r r rrXrYrrrrrr‚Hsr‚cCs|j|jd|jƒS)Nr8)r‚rVr])rrrrr__szStdExpPathPrinter.childrenN) r r rrrXr=rgrr‚r_rrrrr7.sr7c@s@eZdZdZdd„Zdd„Zdd„ZGdd „d eƒZd d„Z dS) ÚStdPathPrinterzPrint a std::filesystem::path.cCsP||_||_t|jddƒ}|jtjdƒƒd@|_|jdkrF||_nd|_dS)Nr8r„Z uintptr_tér)rVr]rprbrrrÆÚ_impl)rrDrWr¯rrrrXfs zStdPathPrinter.__init__cCsHt|jjtj|jdƒƒƒ}|dd…dkr0dS|d d…dkrDdSdS) Nz::_Typerþr:zroot-directoryr;r<z root-namei÷ÿÿÿiöÿÿÿ)r!rÆrbrrr])rr0rrrr=pszStdPathPrinter._path_typecCs8d|jd}|jdkr0|jƒ}|r0d||f}d|S)Nz%sr>rz%s [%s]zfilesystem::path %s)rVrÆr=)rr?r0rrrrgxs zStdPathPrinter.to_stringc@s$eZdZdd„Zdd„Zdd„ZdS)zStdPathPrinter._iteratorc Cs²||_|r¢tjdƒ}tj|dƒ}tjdƒ}|j|jƒƒ}|jƒ}ttjdƒrbtd|j |j ƒ}n d|j }|j|jƒƒ|}|j|jƒƒ|_|j||_d|_ nd|_d|_dS)Nr¤z::_CmptÚcharÚalignofrr)r@rrrbrartrµr:Úmaxr™rFr•r—r~) rr¯rAZint_typeZ cmpt_typeÚ char_typerÚZsizeof_ImplÚbeginrrrrXs z!StdPathPrinter._iterator.__init__cCs|S)Nr)rrrrrY˜sz!StdPathPrinter._iterator.__iter__cCsd|j|jkrt‚|jjƒ}|j}|jd|_|jd|_|d}t|j|ƒjƒ}|sX|}d||fS)Nr)r>z[%s])r•r—rZrtr~rBr@r=)rrÊrEr?r0rrrr›s z!StdPathPrinter._iterator.__next__N)r r rrXrYrrrrrr‚€sr‚cCs|j|j|jƒS)N)r‚rDr])rrrrr_¨szStdPathPrinter.childrenN) r r rrrXr=rgrr‚r_rrrrrBcs (rBc@s8eZdZdZdd„ZGdd„deƒZdd„Zdd „Zd S)ÚStdPairPrinterz@Print a std::pair object, with 'first' and 'second' as children.cCs ||_dS)N)rV)rrDrWrrrrX¯szStdPairPrinter.__init__c@s(eZdZdZdd„Zdd„Zdd„ZdS) zStdPairPrinter._iterz?An iterator for std::pair types. Returns 'first' then 'second'.cCs||_d|_dS)NrÈ)rVÚ_which)rrWrrrrXµszStdPairPrinter._iter.__init__cCs|S)Nr)rrrrrY¹szStdPairPrinter._iter.__iter__cCs8|jdkrt‚|j}|dkr$d|_nd|_||j|fS)NrÈrÉ)rKrZrV)rZwhichrrrr¼s zStdPairPrinter._iter.__next__N)r r rrrXrYrrrrrrË²srËcCs|j|jƒS)N)rËrV)rrrrr_ÆszStdPairPrinter.childrencCsdS)Nr)rrrrrgÉszStdPairPrinter.to_stringN) r r rrrXrrËr_rgrrrrrJ¬s rJc@s eZdZdZdd„Zdd„ZdS)ÚStdCmpCatPrinterz#Print a comparison category object.cCs&||jdƒdd…|_|d|_dS)Nú:r)r,)Úrfindr]rV)rrDrWrrrrXÐszStdCmpCatPrinter.__init__cCsJ|jdkr|jdkrd}n"dddddddd i}|t|jƒ}d j|j|ƒS)NÚstrong_orderingrZequalrZ unorderedr)ZlessZ equivalentZgreaterzstd::{}::{}ri)r]rVr¤r*)rr"ÚnamesrrrrgÔs zStdCmpCatPrinter.to_stringN)r r rrrXrgrrrrrLÍsrLc@s`eZdZdZdZdd„Zedd„ƒZedd„ƒZ ed d „ƒZ edd„ƒZed d„ƒZdd„Z dS)ÚStdErrorCodePrinterz0Print a std::error_code or std::error_condition.NcCsL||_t|ƒ|_tjdkrHyddl}dt_Wntk rFdt_YnXdS)NrTF)rVr;r]rQÚ_system_is_posixÚposixÚImportError)rrDrWrSrrrrXâs zStdErrorCodePrinter.__init__cCs&tj|ƒ}|dk r"|jtjkr"|SdS)N)rrrŸZTYPE_CODE_ENUM)r"r#rrrÚ_find_errc_enumís z#StdErrorCodePrinter._find_errc_enumcCsBxs( zStdErrorCodePrinter.to_string)r r rrrRrXr°rUÚclassmethodrXr]rdrfrgrrrrrQÝs +rQc@s eZdZdZdd„Zdd„ZdS)ÚStdRegexStatePrinterz/Print a state node in the NFA for a std::regex.cCs||_||_dS)N)rVr])rrDrWrrrrX[szStdRegexStatePrinter.__init__cCs–t|jdƒ}|r|dd…}|jd}ddddddddddddddœ }||}d j||ƒ}|dk rŽ|jd |dk rŽdj|||jd |ƒ}d|S) NZ _M_opcodeérzZaltZsubexprÚnegZ backref_index) ÚrepeatÚalternativeZ subexpr_beginZsubexpr_endZline_begin_assertionZline_end_assertionZ word_boundaryZsubexpr_lookaheadZbackrefr?ZacceptZdummyÚunknownzopcode={}, next={}Z_M_z {}, {}={}z{%s})r!rVr*)rZopcodeZnext_idZvariantsÚvr#rrrrg_s zStdRegexStatePrinter.to_stringN)r r rrrXrgrrrrrlXsrlc@s@eZdZdZGdd„deƒZdd„Zdd„Zdd „Zd d„Z dS) ÚStdSpanPrinterzPrint a std::span.c@s$eZdZdd„Zdd„Zdd„ZdS)zStdSpanPrinter._iteratorcCsd|_||_||_dS)Nr)r~Ú_beginr¸)rrIrÚrrrrXysz!StdSpanPrinter._iterator.__init__cCs|S)Nr)rrrrrY~sz!StdSpanPrinter._iterator.__iter__cCs8|j|jkrt‚|j}|jd|_d||j|jƒfS)Nr)z[%d])r~r¸rZrtrt)rrErrrrs z!StdSpanPrinter._iterator.__next__N)r r rrXrYrrrrrr‚xsr‚cCsLt|ƒ|_||_tjdƒ}|jjdƒ|kr:|dd|_n|jjdƒ|_dS)Nzstatic_cast(-1)r)Z _M_extentZ_M_extent_value)r;r]rVrrórr4r¸)rrDrWZsize_maxrrrrX‰s zStdSpanPrinter.__init__cCsd|j|jfS)Nz%s of length %d)r]r¸)rrrrrg’szStdSpanPrinter.to_stringcCs|j|jd|jƒS)Nr\)r‚rVr¸)rrrrr_•szStdSpanPrinter.childrencCsdS)Nr§r)rrrrr¨˜szStdSpanPrinter.display_hintN) r r rrrr‚rXrgr_r¨rrrrrsus rsc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)ÚStdInitializerListPrinterzPrint a std::initializer_list.cCs||_||_|d|_dS)Nr6)r]rVr¸)rrDrWrrrrXŸsz"StdInitializerListPrinter.__init__cCsd|j|jfS)Nz%s of length %d)r]r¸)rrrrrg¤sz#StdInitializerListPrinter.to_stringcCstj|jd|jƒS)NZ_M_array)rsr‚rVr¸)rrrrr_§sz"StdInitializerListPrinter.childrencCsdS)Nr§r)rrrrr¨ªsz&StdInitializerListPrinter.display_hintN)r r rrrXrgr_r¨rrrrruœs ruc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚStdAtomicPrinterzPrint a std:atomic.cCsrt|ƒ|_||_d|_|jjjdƒ|_|jjdk rnt|jjƒ}|jdƒsR|jdƒrn|d}t ||ƒ|_|j |_dS)Nrzstd::shared_ptr = { %s })rwrgr1rŸrZ TYPE_CODE_INTrVÚ TYPE_CODE_FLTÚ TYPE_CODE_PTRr r]r!)rrWrrrrgÁs zStdAtomicPrinter.to_stringN)r r rrrXrxrgrrrrrv®s rvc@s eZdZdZdd„Zdd„ZdS)ÚStdFormatArgsPrinterzPrint a std::basic_format_args.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX×s zStdFormatArgsPrinter.__init__cCs€t|jjƒ}t|dƒd}|tjdƒkr0d}n|tjdƒkrDd}nd}|jd}|dkrbd |S|dkrt|jd }d||fS)Nrr)rEzstd::format_argsÚwchar_tzstd::wformat_argszstd::basic_format_argsZ_M_packed_sizez%s with 1 argumentZ_M_unpacked_sizez%s with %d arguments)rTrVrrr)rZtargsrHr#rÚrrrrgÛs zStdFormatArgsPrinter.to_stringN)r r rrrXrgrrrrr{Òsr{c@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)ÚStdChronoDurationPrinterzPrint a std::chrono::duration.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrXðs z!StdChronoDurationPrinter.__init__cCs*|jjjdƒ}|jdƒ}|jdƒ}||fS)Nr)r)rVrr4)rZperiodrÂÚdenrrrÚ_ratioôs zStdChronoDurationPrinter._ratiocCsˆ|jƒ\}}|dkrF|dkr dS|dkr,dS|dkr8dS|dkr|dSn6|dkr||d krZd S|dkrfdS|d krrdSdj|ƒSdj||ƒS)Nr)r#ièZmsi@BÚusiÊš;rWé<ÚminiÚhi€QÚdz[{}]sz[{}/{}]s)rr*)rrÂr~rrrÚ_suffixûs& z StdChronoDurationPrinter._suffixcCs4|jd}|jjƒjtjkr$d|}dj||jƒƒS)NÚ__rz%gz"std::chrono::duration = {{ {}{} }})rVrrrŸrryr*r…)rÚrrrrrgs z"StdChronoDurationPrinter.to_stringN)r r rrrXrr…rgrrrrr}ís r}c@s*eZdZdZdd„Zdd„Zd dd„Zd S)ÚStdChronoTimePointPrinterz Print a std::chrono::time_point.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrXs z"StdChronoTimePointPrinter.__init__cCsv|jjjdƒ}t|jƒ}|dks(|dkr,dS|dkr8dS|dkrDdS|d krPdS|dkr\dS|dkrhdSdj|ƒdfS)Nrzstd::chrono::_V2::system_clockzstd::chrono::system_clockústd::chrono::sys_timezstd::chrono::utc_clockústd::chrono::utc_timezstd::chrono::gps_clockústd::chrono::gps_timezstd::chrono::tai_clockústd::chrono::tai_timezstd::filesystem::__file_clockústd::chrono::file_timeìumzstd::chrono::local_tústd::chrono::local_timez {} time_point)r‰r)rŠN)r‹N)rŒN)rrŽ)rr)rVrr4r;r"r*)rÚclockr"rrrÚ_clocks z StdChronoTimePointPrinter._clockFc Cs¨|jƒ\}}|jd}|d}t|jj|ƒ}|jƒ}d}|dk r†|jƒ\} } || | |}ytjj|t ƒ}dj |ƒ}WnYnXd|||f} |rœ| Sd|| fS)NZ__dr†rCz [{:%Y-%m-%d %H:%M:%S}]z%d%s%sz%s = { %s })r‘rVr}rr"r…rrZ fromtimestampÚ _utc_timezoner*)rZabbrevrÚoffsetr„r‡ÚprinterÚsuffixÚtimerÂr~Zsecsrr#rrrrg1s$ z#StdChronoTimePointPrinter.to_stringN)F)r r rrrXr‘rgrrrrrˆsrˆc@s eZdZdZdd„Zdd„ZdS)ÚStdChronoZonedTimePrinterz Print a std::chrono::zoned_time.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrXIs z"StdChronoZonedTimePrinter.__init__cCs@|jdjƒd}|jd}t|jj|ƒ}|jdƒ}dj||ƒS)NZ_M_zoneÚ_M_nameZ_M_tpTz%std::chrono::zoned_time = {{ {} {} }})rVrtrˆrr"rgr*)rZzoner–r”rrrrgMs z#StdChronoZonedTimePrinter.to_stringN)r r rrrXrgrrrrr—Fsr—ZJanuaryZFebruaryZMarchZAprilZMayZJuneZJulyZAugustZ SeptemberZOctoberZNovemberZDecemberZSundayZMondayZTuesdayZ WednesdayZThursdayZFridayZSaturdayc@s eZdZdZdd„Zdd„ZdS)ÚStdChronoCalendarPrinterzDPrint a std::chrono::day, std::chrono::month, std::chrono::year etc.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX_s z!StdChronoCalendarPrinter.__init__c Csv|j}|j}d|kr$|dkr$|d}|jdƒr6|d}|dkrPdjt|dƒƒS|d kr||d ksl|ttƒkrtd|St|S|dkrŽdj|ƒS|d krÈ|d}|dks²|ttƒkrºd|Sdjt|ƒS|dkrèdj|dt|dƒƒS|dkrþdj|dƒS|dkrdj||dƒS|dkr,dj|ƒS|dkrFdj||dƒS|dkr`dj||dƒS|dkrvdj||ƒS|dkr’d j|||dƒS|dkr¬dj||d!ƒS|d"krÈd j|||dƒS|d#kräd j|||dƒS|jd$ƒrrd%}|d&dkr"d'jt|d(d)ƒt|d&ƒƒ}t|d*d+ƒ}t|dd+ƒ}t|d,d+ƒ}|d-rb|}d.j||||ƒSdS)/NÚmonthz std::chrono::year_month_day_lastZ_M_mzstd::chrono::yearZ_M_yzstd::chrono::dayz{}Z_M_dzstd::chrono::monthr)z%d is not a valid monthz{}yzstd::chrono::weekdayZ_M_wdrz%d is not a valid weekdayzstd::chrono::weekday_indexedz{}[{}]r.zstd::chrono::weekday_lastz{}[last]zstd::chrono::month_dayz{}/{}zstd::chrono::month_day_lastz{}/lastzstd::chrono::month_weekdayZ_M_wdizstd::chrono::month_weekday_lastZ_M_wdlzstd::chrono::year_monthzstd::chrono::year_month_dayz{}/{}/{}Z_M_mdlzstd::chrono::year_month_weekdayz$std::chrono::year_month_weekday_lastzstd::chrono::hh_mm_ssrCZfractional_widthz.{:0{}d}Z_M_ssZ_M_rrr†Ú_M_sZ _M_is_negz{:02}:{:02}:{:02}{})rVr]r<r*r¤rÚmonthsÚweekdays) rrWr#r"ÚyZwdZfractrƒr#rrrrgcsh z"StdChronoCalendarPrinter.to_stringN)r r rrrXrgrrrrr™\sr™c@s eZdZdZdd„Zdd„ZdS)ÚStdChronoTimeZonePrinterz4Print a chrono::time_zone or chrono::time_zone_link.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrXžs z!StdChronoTimeZonePrinter.__init__cCs6d|j|jdf}|jjdƒr2|d|jd7}|S)Nz%s = %sr˜Z_linkz -> %sZ _M_target)r]rVrb)rr!rrrrg¢sz"StdChronoTimeZonePrinter.to_stringN)r r rrrXrgrrrrrŸ›srŸc@s eZdZdZdd„Zdd„ZdS)ÚStdChronoLeapSecondPrinterzPrint a chrono::leap_second.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX¬s z#StdChronoLeapSecondPrinter.__init__cCs.|jdd}d|dk}d|jt|ƒ|fS)Nr›r†z+-rz %s %d (%c))rVr]Úabs)rZdaternrrrrg°sz$StdChronoLeapSecondPrinter.to_stringN)r r rrrXrgrrrrr ©sr c@s eZdZdZdd„Zdd„ZdS)ÚStdChronoTzdbPrinterzPrint a chrono::tzdb.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX¹s zStdChronoTzdbPrinter.__init__cCsd|j|jdfS)Nz%s %sÚversion)r]rV)rrrrrg½szStdChronoTzdbPrinter.to_stringN)r r rrrXrgrrrrr¢¶sr¢c@s eZdZdZdd„Zdd„ZdS)ÚStdChronoTimeZoneRulePrinterzPrint a chrono::time_zone rule.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrXÄs z%StdChronoTimeZoneRulePrinter.__init__c CsÜ|jd}|d}t|d}ddddddddœ}|d}d j||j|d ƒƒ}|dkrddj||ƒ}nVt|d }|dkr†dj||ƒ}n4|dkr”d} nd} |d}dj| d|| d||ƒ}dj|jd|jd|jd|ƒS)NÚonÚkindršÚstZndZrd)r)rrCééééZday_of_monthz{}{}Zthrz{} {}Zday_of_weekr)z last {} in {}rrØú<=rÈú>=z{} {} {} {} {}z.time_zone rule {} from {} to {} starting on {}r"ÚfromZto)rØr¬)rÈr)rVrœr*Úgetr) rr¥r¦ršÚsuffixesÚdayZordinal_dayr›ÚweekdayÚ directionrrrrgÈs* z&StdChronoTimeZoneRulePrinter.to_stringN)r r rrrXrgrrrrr¤Ásr¤c@s eZdZdZdd„Zdd„ZdS)ÚStdLocalePrinterzPrint a std::locale.cCs||_||_dS)N)rVr])rrDrWrrrrXæszStdLocalePrinter.__init__csx|jdd}d}|ddkr&d}nFtj|jdƒ}tj|jdƒ}|djƒ}|djƒ}dj||ƒ}||i}d } xN| |krÄ|| dkrÄ|| jƒ}|| jƒ}d j|||ƒ}|||<| d } qxWt|jƒƒ} t| ƒd krä|}nˆt| ƒdkrl| \}}t |jƒƒ} d‰| j |ƒd kr$|}|‰n| j |ƒd kr<|}|‰ˆdk rlt‡fdd „|jƒDƒƒ}dj|ˆƒ}dj||ƒS)Nr„Z_M_namesrCrÚ*z::_S_categoriesz::_S_categories_sizez{}={}r)z{};{}={}rc3s|]\}}|ˆkr|VqdS)Nr)r&r²rR)Úotherrrú sz-StdLocalePrinter.to_string..z with "{}={}"zstd::locale = "{}"{}) rVrrór]rær*r4Úvaluesrr‰rErÚitems)rrPÚmodr"ZcatsZncatrRr[Z cat_namesrZ uniq_namesZn1Zn2Z name_listr)r¶rrgêsD zStdLocalePrinter.to_stringN)r r rrrXrgrrrrr´ãsr´c@s eZdZdZdd„Zdd„ZdS)ÚStdIntegralConstantPrinterz*Print a std::true_type or std::false_type.cCs||_||_dS)N)rVr])rrDrWrrrrX sz#StdIntegralConstantPrinter.__init__cCsL|jjjdƒ}|jjjdƒ}|jtjkr4|r0dSdSt|jƒ}dj|||ƒS)Nrr)zstd::true_typezstd::false_typez {}<{}, {}>) rVrr4rŸrr r;r]r*)rr3rZrDrrrrg s z$StdIntegralConstantPrinter.to_stringN)r r rrrXrgrrrrr» sr»c@s eZdZdZdd„Zdd„ZdS)ÚStdTextEncodingPrinterzPrint a std::text_encoding.cCs||_||_dS)N)rVr])rrDrWrrrrX$ szStdTextEncodingPrinter.__init__cCs<|jdjƒ}|ddkr$|jdS|ddkr4dS|dS)NZ_M_repZ_M_idr)r˜rrq)rVrt)rZreprrrrg( s z StdTextEncodingPrinter.to_stringN)r r rrrXrgrrrrr¼! sr¼cs$eZdZ‡fdd„Zdd„Z‡ZS)Ú RxPrintercs$tt|ƒjƒ||_||_d|_dS)NT)rr½rXr"Ú _functionÚenabled)rr"r)r$rrrX3 szRxPrinter.__init__cCs:|js dS|jjtjkr,ttjdƒr,|jƒ}|j|j |ƒS)NÚreferenced_value) r¿rrŸrrärµÚValuerÀr¾r")rrZrrrÚinvoke9 szRxPrinter.invoke)r r rrXrÂr(rr)r$rr½2 sr½csHeZdZ‡fdd„Zdd„Zdd„Zdd„Zed d „ƒZdd„Z ‡Z S) ÚPrintercs6tt|ƒjƒ||_g|_i|_d|_tjdƒ|_ dS)NTz^([a-zA-Z0-9_:]+)(<.*>)?$) rrÃrXr"Ú_subprintersÚ_lookupr¿r>ÚcompileÚ_compiled_rx)rr")r$rrrXH szPrinter.__init__cCs<|jj|ƒstd|ƒ‚t||ƒ}|jj|ƒ||j|<dS)Nz0libstdc++ programming error: "%s" does not match)rÇr?r r½rÄrPrÅ)rr"rr”rrrÚaddP s zPrinter.addcCs>|j|||ƒd|kr:tjddt|ƒ}|j|||ƒdS)NÚ__cxx11z^(std|__gnu_cxx)::z\g<0>%s)rÈr>rHr-)rÚbaser"rZvbaserrrÚadd_version[ s zPrinter.add_versioncCs$|j|||ƒ|j|d||ƒdS)Nz__cxx1998::)rË)rrÊr"rrrrÚ add_containerc szPrinter.add_containercCs&|jtjkr|jƒ}|jƒjƒ}|jS)N)rŸrrärÐrårr)rrrrÚget_basic_typeg szPrinter.get_basic_typecCsr|j|jƒ}|sdS|jj|ƒ}|s(dS|jdƒ}|jjtjkrTttj dƒrT|j ƒ}||jkrn|j|j|ƒSdS)Nr)rÀ) rÍrrÇr?rrŸrrärµrÁrÀrÅrÂ)rrWrDr?ÚbasenamerrrÚ__call__r s zPrinter.__call__)r r rrXrÈrËrÌr°rÍrÏr(rr)r$rrÃG srÃ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 >' with 'std::vector'. cCs||_||_d|_dS)NT)r"Ú_defargsr¿)rr"ÚdefargsrrrrX˜ szTemplateTypePrinter.__init__c@s(eZdZdZdd„Zdd„Zdd„ZdS) zTemplateTypePrinter._recognizerz-The recognizer class for TemplateTypePrinter.cCs||_||_dS)N)r"rÑ)rr"rÒrrrrX sz(TemplateTypePrinter._recognizer.__init__c Csú|jdkrdS|jj|jƒs dSt|ƒ}g}d}x”tt|ƒƒD]„}||}|jj|ƒ}|dk rª|j|Ž}y|t j |ƒkr|dSWn$t jk r¢|j|krždSYnXd}q>|r²dS|j|j |ƒƒq>W|jd|jjdƒ…}t|ƒ}|ddj|ƒ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ú)rr<r"rTÚrangerrÑr¯r*rrr,rPÚ_recognize_subtyperárOr+) rrQrSZdisplayed_argsZrequire_defaultedrRrfZdefargrArrrÚ recognize¥ s2 z)TemplateTypePrinter._recognizer.recognizecCsÔ|jtjkr|j|jƒƒdS|jtjkrj|j|jƒƒ}t|jƒƒjdƒrR|dSd||j ƒddfS|jtj krˆ|j|jƒƒdSttdƒr°|jtjkr°|j|jƒƒdStj jtj jƒ|ƒ}|rÌ|St|ƒS)zxConvert a gdb.Type to a string by applying recognizers, or if that fails then simply converting to a string.rµz[]z%s[%d]r)ú&ÚTYPE_CODE_RVALUE_REFz&&)rŸrrzrÖrÐrÏr!rrbrÕrärµrÙrrr)rrQrNrrrrÖÖ s" z2TemplateTypePrinter._recognizer._recognize_subtypeN)r r rrrXr×rÖrrrrÚ_recognizer s1rÚcCs|j|j|jƒS)z1Return a recognizer object for this type printer.)rÚr"rÑ)rrrrÚinstantiateí szTemplateTypePrinter.instantiateN)r r rrrXÚobjectrÚrÛrrrrrÐ s PrÐcsžtd||ƒ}tjj||ƒtd||ƒ}tjj||ƒd|kršdt‰t‡fdd„|jƒDƒƒ}tˆ||ƒ}tjj||ƒtd||ƒ}tjj||ƒ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 >' } zstd::zstd::__debug::rÉc3s"|]\}}||jdˆƒfVqdS)zstd::N)r.)r&rRr„)rWrrr· sz0add_one_template_type_printer..N)rÐrrÚregister_type_printerr-Údictr¹)Úobjr"rÒr”r)rWrÚadd_one_template_type_printerò sràc@s2eZdZdZd dd„ZGdd„deƒZdd„ZdS) ÚFilteringTypePrintera› A type printer that uses typedef names for common template specializations. Args: template (str): The class template to recognize. name (str): The typedef-name that will be used instead. targ1 (str, optional): The first template argument. Defaults to None. Checks if a specialization of the class template 'template' is the same type as the typedef 'name', and prints it as 'name' instead. e.g. if an instantiation of std::basic_istream is the same type as std::istream then print it as std::istream. If targ1 is provided (not None), match only template specializations with this type as the first template argument, e.g. if template='basic_string' and targ1='char' then only match 'basic_string' and not 'basic_string'. This rejects non-matching specializations more quickly, without needing to do GDB type lookups. NcCs||_||_||_d|_dS)NT)Ú _templater"Ú_targ1r¿)rÚtemplater"Útarg1rrrrX- szFilteringTypePrinter.__init__c@s eZdZdZdd„Zdd„ZdS)z FilteringTypePrinter._recognizerz.The recognizer class for FilteringTypePrinter.cCs||_||_||_d|_dS)N)râr"rãÚ _type_obj)rrär"rårrrrX6 sz)FilteringTypePrinter._recognizer.__init__c Csü|jdkrdS|jdkrz|jdk rDdj|j|jƒ}|jj|ƒsVdSn|jj|jƒsVdSytj|jƒj ƒ|_WnYnX|jdkrˆdStj j|jƒ}tj j|ƒ}||kr´t|jƒS|jj dƒddkrø|jjjddƒ}|jjddƒ}||krøt|jƒSdS) z• If type_obj starts with self._template and is the same type as self.name then return self.name, otherwise None. Nz{}<{}z::r)Úbasic_stringz __cxx11::rCri)rrærãr*râr<rrr"rrrÍrOrer.)rrQr#Zt1Zt2Ús1Ús2rrrr×< s4 z*FilteringTypePrinter._recognizer.recognizeN)r r rrrXr×rrrrrÚ3 srÚcCs|j|j|j|jƒS)z1Return a recognizer object for this type printer.)rÚrâr"rã)rrrrrÛf sz FilteringTypePrinter.instantiate)N)r r rrrXrÜrÚrÛrrrrrá s 3rácCsXtd|d||ƒ}tjj||ƒd|krTdt}t|||||ƒ}tjj||ƒdS)Nzstd::rÉ)rárrrÝr-)rßrär"rår”rWrrrÚadd_one_type_printerk srêc CsdtsdSxxdgD]p}t|d|dd |dƒt|d|dd |dƒt|dd|dd |dƒt|d|dd|dƒqWx„djD]|}x*dkD]"}t|d||d||dƒq’WxJdlD]B}t|d||d||dƒt|d!||d||dƒq¾WqˆWxdmD]ˆ}x0dpD](}t||d"||dd#|dƒqWxNdqD]F}t||d(||d)ƒx&drD]}t||||||ƒqlWqJWqWt|d-d.ƒxdsD]}t|d9d:|ƒq¬Wt|d;d<ƒt|d;d=ƒt|d>d?ƒt|d>d@ƒt|dAdBƒt|dAdCƒt|dDdEƒt|dDdFƒt|dGdHƒdI}x0dyD](}t||d||dd|dƒqÚdequezstd::allocator<{0}>r‹r‰z __cxx11::listÚvectorrÌzstd::less<{0}>z)std::allocator>)rrCÚmultimapr4)r)rÚmultisetÚ unordered_mapzstd::hash<{0}>zstd::equal_to<{0}>)rrCéÚunordered_multimapÚ unordered_set)r)rrCÚunordered_multiset©rCrE©rÑr|©rërì©rírî©rïrð)rrrrr©rCrE©rÑr|)rr) rórérôrõrör÷rørùrú)rürýrþrÿ)rCrñ©rCrE©rÑr|)rr )r²r#rr)rrr) rrrrr r rrr rœ©rCrE©rÑr|©rërì©rírî©rïrð)r!r"r#r$r%)rrêrà)rßZchr@ÚabiZdurrWrrrÚregister_type_printerst s® "( * r'cCs8trtjj|tƒn|dkr t}|jjtƒt|ƒdS)z4Register libstdc++ pretty-printers with objfile Obj.N)Ú_use_gdb_pprZprintingZregister_pretty_printerÚlibstdcxx_printerZpretty_printersrPr')rßrrrÚregister_libstdcxx_printersã sr*cCsXtdƒatjddtƒtjddtƒtjddtƒtjddtƒtjddtƒtjddtƒtjddtƒtjdd tƒtjdd t ƒtjddt ƒtjddtƒtjdd tƒtjddtƒtjddt ƒtjddtƒtjddt ƒtjddtƒtjddtƒttjdƒr.tjddtƒtjddtƒtjdtƒtjdtƒtjdtƒtjdtƒtjdtƒtjdt ƒtjdt ƒtjdtƒtjddtƒtjdd tƒtjdd!tƒtjdd"tƒtjdd#tƒtjdd$tƒtjdd%tƒtjd&dtƒtjd&d tƒtjd&d!tƒtjd&d"tƒtjd&d#tƒtjd&d$tƒtjdd'tƒtjdd(tƒtjdd)tƒtjdd)tƒx2doD]*}tjdd-|tƒtjdd-|tƒq‚Wtjd.d/tƒtjd.d0tƒtjdd1tƒtjd2d3t ƒtjd4tƒtjd5tƒtjd6tƒtjd7tƒtjd8tƒtjd9d:t!ƒtjd9d;t"ƒtjd9dt$ƒtjd?d>t$ƒtjd@d>t%ƒtjdAd>t%ƒtjdd:t!ƒtjdd;t"ƒtjddrFrirrGrÜrrÌr Úziprr¤rÞZtimezoneZutcr’Ztzinforr(Zgdb.printingrTrZ gdb.typesrµrrZprinter_baser%r-r2r8r5rBr;rKrOrTrUr[rkrmrprqrurxryr†rˆrŠrrrr©rªr«r¬r±r¶r½r¾rÁrÃrÄrÍrÎrÓrßràrírîrðrörürr rrrrr)r-r0r5r7rBrJrLrQrlrsrurvr{r}rˆr—rœrr™rŸr r¢r¤r´r»r¼r½rÃr)rÐràrárêr'r*r;rrrrÚsö % (&"I U(*$/A" /%-^!,5I!{'$*/? ",Ce%T oTPKr1]äÔeæŽæŽ7python/libstdcxx/v6/__pycache__/xmethods.cpython-36.pycnu„[µü¤3 À¡hqã@sœddlZddlZddlZdZdd„Zdd„ZdZdd „ZGd d„dejj ƒZ Gdd „d ejjƒZGdd„deƒZ Gdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„dejjƒZGdd„dejjƒZGdd„deƒZGd d!„d!eƒZGd"d#„d#eƒZGd$d%„d%eƒZGd&d'„d'eƒZGd(d)„d)eƒZGd*d+„d+ejjƒZGd,d-„d-ejjƒZGd.d/„d/eƒZGd0d1„d1eƒZGd2d3„d3ejjƒZ Gd4d5„d5ejjƒZ!Gd6d7„d7e!ƒZ"Gd8d9„d9e!ƒZ#Gd:d;„d;e!ƒZ$Gdd?„d?ejjƒZ&Gd@dA„dAejjƒZ'GdBdC„dCe'ƒZ(GdDdE„dEe'ƒZ)GdFdG„dGe'ƒZ*GdHdI„dIe'ƒZ+GdJdK„dKe'ƒZ,GdLdM„dMe'ƒZ-GdNdO„dOejjƒZ.GdPdQ„dQejjƒZ/GdRdS„dSe/ƒZ0GdTdU„dUe/ƒZ1GdVdW„dWejjƒZ2GdXdY„dYejjƒZ3GdZd[„d[e3ƒZ4Gd\d]„d]e3ƒZ5Gd^d_„d_ejjƒZ6Gd`da„daejjƒZ7Gdbdc„dce7ƒZ8Gddde„dee7ƒZ9Gdfdg„dgejjƒZ:Gdhdi„die:ƒZ;Gdjdk„dkejjƒZ$N)Ú isinstancerZTypeÚtagÚ_versioned_namespaceÚreÚmatch)ÚxZ template_namerrrÚis_specialization_of!src@seZdZdd„ZdS)ÚLibStdCxxXMethodcCstjjj||ƒ||_dS)N)rÚxmethodÚXMethodÚ__init__Úworker_class)ÚselfÚnamerrrrr.szLibStdCxxXMethod.__init__N)Ú__name__Ú __module__Ú__qualname__rrrrrr-src@seZdZdd„Zdd„ZdS)ÚArrayWorkerBasecCs||_||_dS)N)Ú _val_typeÚ_size)rÚval_typeÚsizerrrr6szArrayWorkerBase.__init__cCstjdƒ}|j|jjƒƒjƒS)Nz (void *) 0)rZparse_and_evalÚcastrÚpointerÚdereference)rZnullptrrrrÚ null_value:s zArrayWorkerBase.null_valueN)rrrrr"rrrrr5src@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) ÚArraySizeWorkercCstj|||ƒdS)N)rr)rrrrrrr@szArraySizeWorker.__init__cCsdS)Nr)rrrrÚ get_arg_typesCszArraySizeWorker.get_arg_typescCstƒS)N)r)rÚobjrrrÚget_result_typeFszArraySizeWorker.get_result_typecCs|jS)N)r)rr%rrrÚ__call__IszArraySizeWorker.__call__N)rrrrr$r&r'rrrrr#?sr#c@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) ÚArrayEmptyWorkercCstj|||ƒdS)N)rr)rrrrrrrNszArrayEmptyWorker.__init__cCsdS)Nr)rrrrr$QszArrayEmptyWorker.get_arg_typescCstƒS)N)r)rr%rrrr&Tsz ArrayEmptyWorker.get_result_typecCst|jƒdkS)Nr)Úintr)rr%rrrr'WszArrayEmptyWorker.__call__N)rrrrr$r&r'rrrrr(Msr(c@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) ÚArrayFrontWorkercCstj|||ƒdS)N)rr)rrrrrrr\szArrayFrontWorker.__init__cCsdS)Nr)rrrrr$_szArrayFrontWorker.get_arg_typescCs|jS)N)r)rr%rrrr&bsz ArrayFrontWorker.get_result_typecCs&t|jƒdkr|ddS|jƒSdS)NrÚ_M_elems)r)rr")rr%rrrr'eszArrayFrontWorker.__call__N)rrrrr$r&r'rrrrr*[sr*c@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) ÚArrayBackWorkercCstj|||ƒdS)N)rr)rrrrrrrmszArrayBackWorker.__init__cCsdS)Nr)rrrrr$pszArrayBackWorker.get_arg_typescCs|jS)N)r)rr%rrrr&sszArrayBackWorker.get_result_typecCs,t|jƒdkr |d|jdS|jƒSdS)Nrr+é)r)rr")rr%rrrr'vszArrayBackWorker.__call__N)rrrrr$r&r'rrrrr,lsr,c@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) Ú ArrayAtWorkercCstj|||ƒdS)N)rr)rrrrrrr~szArrayAtWorker.__init__cCstƒS)N)r)rrrrr$szArrayAtWorker.get_arg_typescCs|jS)N)r)rr%Úindexrrrr&„szArrayAtWorker.get_result_typecCs4t|ƒt|jƒkr(tdt|ƒ|jfƒ‚|d|S)Nz%Array index "%d" should not be >= %d.r+)r)rÚ IndexError)rr%r/rrrr'‡szArrayAtWorker.__call__N)rrrrr$r&r'rrrrr.}sr.c@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) ÚArraySubscriptWorkercCstj|||ƒdS)N)rr)rrrrrrrszArraySubscriptWorker.__init__cCstƒS)N)r)rrrrr$’sz"ArraySubscriptWorker.get_arg_typescCs|jS)N)r)rr%r/rrrr&•sz$ArraySubscriptWorker.get_result_typecCs&t|jƒdkr|d|S|jƒSdS)Nrr+)r)rr")rr%r/rrrr'˜szArraySubscriptWorker.__call__N)rrrrr$r&r'rrrrr1Žsr1c@seZdZdd„Zdd„ZdS)ÚArrayMethodsMatchercsftjjjˆtdƒtdtƒtdtƒtdtƒtdt ƒtdt ƒtdtƒdœˆ_‡fd d „ˆjDƒˆ_ dS)NÚarrayrÚemptyÚfrontÚbackÚatz operator[])rr4r5r6r7z operator[]csg|]}ˆj|‘qSr)Ú_method_dict)Ú.0Úm)rrrú «sz0ArrayMethodsMatcher.__init__..)rrÚXMethodMatcherrÚmatcher_name_prefixrr#r(r*r,r.r1r8Úmethods)rr)rrr s zArrayMethodsMatcher.__init__c Cs^t|dƒsdS|jj|ƒ}|dks*|jr.dSy|jdƒ}|jdƒ}Wn dS|j||ƒS)Nr3rr-)rr8ÚgetÚenabledÚtemplate_argumentr)rÚ class_typeÚmethod_nameÚmethodZ value_typerrrrr s zArrayMethodsMatcher.matchN)rrrrr rrrrr2Ÿs r2c@s$eZdZdd„Zdd„Zdd„ZdS)ÚDequeWorkerBasecCs||_d|jpd|_dS)Nir-)rÚsizeofÚ_bufsize)rrrrrr¿szDequeWorkerBase.__init__cCsf|dd}|dd}|d|dkr,dS|j|d|dd|d|d|d |dS) NÚ_M_implÚ_M_startÚ _M_finishÚ_M_currÚ_M_noder-Ú_M_firstÚ_M_last)rG)rr%ÚstartÚfinishrrrrÃs zDequeWorkerBase.sizecCs`|dd}|d|d}||kr0|d|S||}|ddt|ƒ|j}|||jS)NrHrIrNrKrLr-)r)rG)rr%ÚidxrOZfirst_node_sizeZ index_noderrrr/ÍszDequeWorkerBase.indexN)rrrrrr/rrrrrE¾s rEc@s$eZdZdd„Zdd„Zdd„ZdS)ÚDequeEmptyWorkercCsdS)Nr)rrrrr$ØszDequeEmptyWorker.get_arg_typescCstƒS)N)r)rr%rrrr&Ûsz DequeEmptyWorker.get_result_typecCs |ddd|dddkS)NrHrIrKrJr)rr%rrrr'ÞszDequeEmptyWorker.__call__N)rrrr$r&r'rrrrrR×srRc@s$eZdZdd„Zdd„Zdd„ZdS)ÚDequeSizeWorkercCsdS)Nr)rrrrr$äszDequeSizeWorker.get_arg_typescCstƒS)N)r)rr%rrrr&çszDequeSizeWorker.get_result_typecCs |j|ƒS)N)r)rr%rrrr'êszDequeSizeWorker.__call__N)rrrr$r&r'rrrrrSãsrSc@s$eZdZdd„Zdd„Zdd„ZdS)ÚDequeFrontWorkercCsdS)Nr)rrrrr$ïszDequeFrontWorker.get_arg_typescCs|jS)N)r)rr%rrrr&òsz DequeFrontWorker.get_result_typecCs|ddddS)NrHrIrKrr)rr%rrrr'õszDequeFrontWorker.__call__N)rrrr$r&r'rrrrrTîsrTc@s$eZdZdd„Zdd„Zdd„ZdS)ÚDequeBackWorkercCsdS)Nr)rrrrr$úszDequeBackWorker.get_arg_typescCs|jS)N)r)rr%rrrr&ýszDequeBackWorker.get_result_typecCs^|ddd|dddkrF|dddd}|d|jdS|ddddSdS) NrHrJrKrMrLr-réÿÿÿÿ)rG)rr%Ú prev_noderrrr's zDequeBackWorker.__call__N)rrrr$r&r'rrrrrUùsrUc@s$eZdZdd„Zdd„Zdd„ZdS)ÚDequeSubscriptWorkercCstƒS)N)r)rrrrr$ sz"DequeSubscriptWorker.get_arg_typescCs|jS)N)r)rr%Ú subscriptrrrr& sz$DequeSubscriptWorker.get_result_typecCs|j||ƒS)N)r/)rr%rYrrrr'szDequeSubscriptWorker.__call__N)rrrr$r&r'rrrrrX srXc@s$eZdZdd„Zdd„Zdd„ZdS)Ú DequeAtWorkercCstƒS)N)r)rrrrr$szDequeAtWorker.get_arg_typescCs|jS)N)r)rr%r/rrrr&szDequeAtWorker.get_result_typecCs@t|j|ƒƒ}t|ƒ|kr0tdt|ƒ|fƒ‚n|j||ƒSdS)Nz%Deque index "%d" should not be >= %d.)r)rr0r/)rr%r/Z deque_sizerrrr's zDequeAtWorker.__call__N)rrrr$r&r'rrrrrZsrZc@seZdZdd„Zdd„ZdS)ÚDequeMethodsMatchercsftjjjˆtdƒtdtƒtdtƒtdtƒtdt ƒtdt ƒtdtƒdœˆ_‡fd d „ˆjDƒˆ_ dS)NÚdequer4rr5r6z operator[]r7)r4rr5r6z operator[]r7csg|]}ˆj|‘qSr)r8)r9r:)rrrr;0sz0DequeMethodsMatcher.__init__..)rrr<rr=rrRrSrTrUrXrZr8r>)rr)rrr%s zDequeMethodsMatcher.__init__cCs>t|dƒsdS|jj|ƒ}|dks*|jr.dS|j|jdƒƒS)Nr\r)rr8r?r@rrA)rrBrCrDrrrr 2s zDequeMethodsMatcher.matchN)rrrrr rrrrr[$s r[c@seZdZdd„Zdd„ZdS)ÚForwardListWorkerBasecCs||_||_dS)N)rÚ _node_type)rrÚ node_typerrrr>szForwardListWorkerBase.__init__cCsdS)Nr)rrrrr$Bsz#ForwardListWorkerBase.get_arg_typesN)rrrrr$rrrrr]=sr]c@seZdZdd„Zdd„ZdS)ÚForwardListEmptyWorkercCstƒS)N)r)rr%rrrr&Gsz&ForwardListEmptyWorker.get_result_typecCs|ddddkS)NrHÚ_M_headÚ_M_nextrr)rr%rrrr'JszForwardListEmptyWorker.__call__N)rrrr&r'rrrrr`Fsr`c@seZdZdd„Zdd„ZdS)ÚForwardListFrontWorkercCs|jS)N)r)rr%rrrr&Osz&ForwardListFrontWorker.get_result_typecCs:|dddj|jƒ}|ddj}|j|jjƒƒjƒS)NrHrarbÚ _M_storage)rr^Úaddressrr r!)rr%ÚnodeZval_addressrrrr'RszForwardListFrontWorker.__call__N)rrrr&r'rrrrrcNsrcc@seZdZdd„Zdd„ZdS)ÚForwardListMethodsMatchercsJtd}tjjjˆ|ƒtdtƒtdtƒdœˆ_‡fdd„ˆjDƒˆ_ dS)NÚforward_listr4r5)r4r5csg|]}ˆj|‘qSr)r8)r9r:)rrrr;`sz6ForwardListMethodsMatcher.__init__..) r=rrr<rrr`rcr8r>)rZmatcher_namer)rrrYs z"ForwardListMethodsMatcher.__init__cCsZt|dƒsdS|jj|ƒ}|dks*|jr.dS|jdƒ}tjt|ƒdƒjƒ}|j ||ƒS)Nrhrz::_Node) rr8r?r@rArrÚstrr r)rrBrCrDrr_rrrr bs zForwardListMethodsMatcher.matchN)rrrrr rrrrrgXs rgc@s$eZdZdd„Zdd„Zdd„ZdS)ÚListWorkerBasecCs||_||_dS)N)rr^)rrr_rrrrpszListWorkerBase.__init__cCsdS)Nr)rrrrr$tszListWorkerBase.get_arg_typescCsB|jƒ}|jjƒdjdkr$|dS|dj}|j|jjƒƒjƒS)Nr-Z_M_datard)r!ÚtypeÚfieldsrrerrr )rrfZaddrrrrÚget_value_from_nodews z"ListWorkerBase.get_value_from_nodeN)rrrrr$rmrrrrrjosrjc@seZdZdd„Zdd„ZdS)ÚListEmptyWorkercCstƒS)N)r)rr%rrrr&‚szListEmptyWorker.get_result_typecCs&|dd}|d|jkrdSdSdS)NrHrLrbTF)re)rr%Z base_noderrrr'…szListEmptyWorker.__call__N)rrrr&r'rrrrrnsrnc@seZdZdd„Zdd„ZdS)ÚListSizeWorkercCstƒS)N)r)rr%rrrr&ŽszListSizeWorker.get_result_typecCsD|ddd}|ddj}d}x||kr>|d}|d7}q$W|S)NrHrLrbrr-)re)rr%Z begin_nodeZend_noderrrrr'‘s zListSizeWorker.__call__N)rrrr&r'rrrrrosroc@seZdZdd„Zdd„ZdS)ÚListFrontWorkercCs|jS)N)r)rr%rrrr&œszListFrontWorker.get_result_typecCs"|dddj|jƒ}|j|ƒS)NrHrLrb)rr^rm)rr%rfrrrr'ŸszListFrontWorker.__call__N)rrrr&r'rrrrrp›srpc@seZdZdd„Zdd„ZdS)ÚListBackWorkercCs|jS)N)r)rr%rrrr&¥szListBackWorker.get_result_typecCs"|dddj|jƒ}|j|ƒS)NrHrLZ_M_prev)rr^rm)rr%rWrrrr'¨szListBackWorker.__call__N)rrrr&r'rrrrrq¤srqc@seZdZdd„Zdd„ZdS)ÚListMethodsMatchercsVtjjjˆtdƒtdtƒtdtƒtdtƒtdt ƒdœˆ_ ‡fdd„ˆj Dƒˆ_dS) NÚlistr4rr5r6)r4rr5r6csg|]}ˆj|‘qSr)r8)r9r:)rrrr;·sz/ListMethodsMatcher.__init__..)rrr<rr=rrnrorprqr8r>)rr)rrr®s zListMethodsMatcher.__init__cCsZt|dƒsdS|jj|ƒ}|dks*|jr.dS|jdƒ}tjt|ƒdƒjƒ}|j ||ƒS)Nz(__cxx11::)?listrz::_Node) rr8r?r@rArrrir r)rrBrCrDrr_rrrr ¹s zListMethodsMatcher.matchN)rrrrr rrrrrrsrrc@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorWorkerBasecCs ||_dS)N)r)rrrrrrÇszVectorWorkerBase.__init__cCsz|jjtjkr^|ddd}|ddd}|ddd}|jƒjjd}||||S|dd|ddSdS)NrHrIÚ_M_prJZ _M_offseté)rÚcoderÚTYPE_CODE_BOOLr!rkrF)rr%rOrPZ finish_offsetÚbit_sizerrrrÊszVectorWorkerBase.sizecCsj|jjtjkrV|ddd}|jƒjjd}|||}||}|jƒd|>@dkS|dd|SdS)NrHrIrurvr-r)rrwrrxr!rkrF)rr%r/rOryZvalpÚoffsetrrrr?ÔszVectorWorkerBase.getN)rrrrrr?rrrrrtÆs rtc@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorEmptyWorkercCsdS)Nr)rrrrr$àszVectorEmptyWorker.get_arg_typescCstƒS)N)r)rr%rrrr&ãsz!VectorEmptyWorker.get_result_typecCst|j|ƒƒdkS)Nr)r)r)rr%rrrr'æszVectorEmptyWorker.__call__N)rrrr$r&r'rrrrr{ßsr{c@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorSizeWorkercCsdS)Nr)rrrrr$ëszVectorSizeWorker.get_arg_typescCstƒS)N)r)rr%rrrr&îsz VectorSizeWorker.get_result_typecCs |j|ƒS)N)r)rr%rrrr'ñszVectorSizeWorker.__call__N)rrrr$r&r'rrrrr|êsr|c@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorFrontWorkercCsdS)Nr)rrrrr$öszVectorFrontWorker.get_arg_typescCs|jS)N)r)rr%rrrr&ùsz!VectorFrontWorker.get_result_typecCs|j|dƒS)Nr)r?)rr%rrrr'üszVectorFrontWorker.__call__N)rrrr$r&r'rrrrr}õsr}c@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorBackWorkercCsdS)Nr)rrrrr$szVectorBackWorker.get_arg_typescCs|jS)N)r)rr%rrrr&sz VectorBackWorker.get_result_typecCs|j|t|j|ƒƒdƒS)Nr-)r?r)r)rr%rrrr'szVectorBackWorker.__call__N)rrrr$r&r'rrrrr~sr~c@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorAtWorkercCstƒS)N)r)rrrrr$szVectorAtWorker.get_arg_typescCs|jS)N)r)rr%r/rrrr&szVectorAtWorker.get_result_typecCs>t|j|ƒƒ}t|ƒ|kr.tdt|ƒ|fƒ‚|j|t|ƒƒS)Nz&Vector index "%d" should not be >= %d.)r)rr0r?)rr%r/rrrrr's zVectorAtWorker.__call__N)rrrr$r&r'rrrrrsrc@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorSubscriptWorkercCstƒS)N)r)rrrrr$sz#VectorSubscriptWorker.get_arg_typescCs|jS)N)r)rr%rYrrrr&sz%VectorSubscriptWorker.get_result_typecCs|j|t|ƒƒS)N)r?r))rr%rYrrrr'!szVectorSubscriptWorker.__call__N)rrrr$r&r'rrrrr€sr€c@seZdZdd„Zdd„ZdS)ÚVectorMethodsMatchercsftjjjˆtdƒtdtƒtdtƒtdtƒtdt ƒtdt ƒtdtƒdœˆ_‡fd d „ˆjDƒˆ_ dS)NÚvectorrr4r5r6r7z operator[])rr4r5r6r7z operator[]csg|]}ˆj|‘qSr)r8)r9r:)rrrr;2sz1VectorMethodsMatcher.__init__..)rrr<rr=rr|r{r}r~rr€r8r>)rr)rrr&s zVectorMethodsMatcher.__init__cCs>t|dƒsdS|jj|ƒ}|dks*|jr.dS|j|jdƒƒS)Nr‚r)rr8r?r@rrA)rrBrCrDrrrr 4s zVectorMethodsMatcher.matchN)rrrrr rrrrr%src@s$eZdZdd„Zdd„Zdd„ZdS)ÚAssociativeContainerWorkerBasecCs ||_dS)N)Ú _unordered)rÚ unorderedrrrr@sz'AssociativeContainerWorkerBase.__init__cCs&|jr|ddS|dddSdS)NZ_M_hZ_M_element_countÚ_M_trHZ _M_node_count)r„)rr%rrrÚ node_countCsz)AssociativeContainerWorkerBase.node_countcCsdS)Nr)rrrrr$Isz,AssociativeContainerWorkerBase.get_arg_typesN)rrrrr‡r$rrrrrƒ?srƒc@seZdZdd„Zdd„ZdS)ÚAssociativeContainerEmptyWorkercCstƒS)N)r)rr%rrrr&Nsz/AssociativeContainerEmptyWorker.get_result_typecCst|j|ƒƒdkS)Nr)r)r‡)rr%rrrr'Qsz(AssociativeContainerEmptyWorker.__call__N)rrrr&r'rrrrrˆMsrˆc@seZdZdd„Zdd„ZdS)ÚAssociativeContainerSizeWorkercCstƒS)N)r)rr%rrrr&Vsz.AssociativeContainerSizeWorker.get_result_typecCs |j|ƒS)N)r‡)rr%rrrr'Ysz'AssociativeContainerSizeWorker.__call__N)rrrr&r'rrrrr‰Usr‰c@seZdZdd„Zdd„ZdS)Ú"AssociativeContainerMethodsMatchercsLtjjjˆt|ƒ|ˆ_tdtƒtdtƒdœˆ_ ‡fdd„ˆj Dƒˆ_ dS)Nrr4)rr4csg|]}ˆj|‘qSr)r8)r9r:)rrrr;gsz?AssociativeContainerMethodsMatcher.__init__..)rrr<rr=Ú_namerr‰rˆr8r>)rrr)rrr^s z+AssociativeContainerMethodsMatcher.__init__cCsDt||jƒsdS|jj|ƒ}|dks,|jr0dSd|jk}|j|ƒS)Nr…)rr‹r8r?r@r)rrBrCrDr…rrrr is z(AssociativeContainerMethodsMatcher.matchN)rrrrr rrrrrŠ]srŠc@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d„ZdS) ÚUniquePtrGetWorkerzS Implement std::unique_ptr::get() and std::unique_ptr::operator->(). cCs*|jtjk|_|jr |jƒ|_n||_dS)N)rwrÚTYPE_CODE_ARRAYÚ _is_arrayÚtargetÚ _elem_type)rÚ elem_typerrrrzszUniquePtrGetWorker.__init__cCsdS)Nr)rrrrr$sz UniquePtrGetWorker.get_arg_typescCs |jjƒS)N)rr )rr%rrrr&„sz"UniquePtrGetWorker.get_result_typecCs|dkp|jS)Nr?)rŽ)rrCrrrÚ _supports‡szUniquePtrGetWorker._supportscCs¢|jƒjjƒdjj}t|dƒr.|dd}nt|dƒrB|d}ndS|jjƒdj}|jƒdj}|jƒd}|jdkrˆ|j|ƒdS|jrš|j|jƒSdSdS)Nrz__uniq_ptr_(data|impl)r†Útupler-Z_M_head_impl)r!rkrlr rrrZ is_base_class)rr%Z impl_typeZtuple_memberZtuple_impl_typeZtuple_head_typeZ head_fieldrrrr'‹s zUniquePtrGetWorker.__call__N) rrrÚ__doc__rr$r&r’r'rrrrrŒusrŒc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)ÚUniquePtrDerefWorkerz*Implement std::unique_ptr::operator*().cCstj||ƒdS)N)rŒr)rr‘rrrr¢szUniquePtrDerefWorker.__init__cCs|jS)N)r)rr%rrrr&¥sz$UniquePtrDerefWorker.get_result_typecCs|jS)N)rŽ)rrCrrrr’¨szUniquePtrDerefWorker._supportscCstj||ƒjƒS)N)rŒr'r!)rr%rrrr'¬szUniquePtrDerefWorker.__call__N)rrrr”rr&r’r'rrrrr•Ÿs r•c@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d„ZdS) ÚUniquePtrSubscriptWorkerz1Implement std::unique_ptr::operator[](size_t).cCstj||ƒdS)N)rŒr)rr‘rrrr³sz!UniquePtrSubscriptWorker.__init__cCstƒS)N)r)rrrrr$¶sz&UniquePtrSubscriptWorker.get_arg_typescCs|jS)N)r)rr%r/rrrr&¹sz(UniquePtrSubscriptWorker.get_result_typecCs|jS)N)rŽ)rrCrrrr’¼sz"UniquePtrSubscriptWorker._supportscCstj||ƒ|S)N)rŒr')rr%r/rrrr'Àsz!UniquePtrSubscriptWorker.__call__N) rrrr”rr$r&r’r'rrrrr–°sr–c@seZdZdd„Zdd„ZdS)ÚUniquePtrMethodsMatchercsVtjjjˆtdƒtdtƒtdtƒtdtƒtdtƒdœˆ_ ‡fdd„ˆj Dƒˆ_ dS) NÚ unique_ptrr?z operator->z operator*z operator[])r?z operator->z operator*z operator[]csg|]}ˆj|‘qSr)r8)r9r:)rrrr;Îsz4UniquePtrMethodsMatcher.__init__..)rrr<rr=rrŒr•r–r8r>)rr)rrrÅs z UniquePtrMethodsMatcher.__init__cCsPt|dƒsdS|jj|ƒ}|dks*|jr.dS|j|jdƒƒ}|j|ƒrL|SdS)Nr˜r)rr8r?r@rrAr’)rrBrCrDÚworkerrrrr Ðs zUniquePtrMethodsMatcher.matchN)rrrrr rrrrr—Äsr—c@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d„ZdS) ÚSharedPtrGetWorkerzT Implements std::shared_ptr::get() and std::shared_ptr::operator->(). cCs*|jtjk|_|jr |jƒ|_n||_dS)N)rwrrrŽrr)rr‘rrrrãszSharedPtrGetWorker.__init__cCsdS)Nr)rrrrr$êsz SharedPtrGetWorker.get_arg_typescCs |jjƒS)N)rr )rr%rrrr&ísz"SharedPtrGetWorker.get_result_typecCs|dkp|jS)Nr?)rŽ)rrCrrrr’ðszSharedPtrGetWorker._supportscCs|dS)NZ_M_ptrr)rr%rrrr'ôszSharedPtrGetWorker.__call__N) rrrr”rr$r&r’r'rrrrršÞsršc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)ÚSharedPtrDerefWorkerz*Implement std::shared_ptr::operator*().cCstj||ƒdS)N)ršr)rr‘rrrrûszSharedPtrDerefWorker.__init__cCs|jS)N)r)rr%rrrr&þsz$SharedPtrDerefWorker.get_result_typecCs|jS)N)rŽ)rrCrrrr’szSharedPtrDerefWorker._supportscCstj||ƒjƒS)N)ršr'r!)rr%rrrr'szSharedPtrDerefWorker.__call__N)rrrr”rr&r’r'rrrrr›øs r›c@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d„ZdS) ÚSharedPtrSubscriptWorkerz1Implement std::shared_ptr::operator[](size_t).cCstj||ƒdS)N)ršr)rr‘rrrrsz!SharedPtrSubscriptWorker.__init__cCstƒS)N)r)rrrrr$sz&SharedPtrSubscriptWorker.get_arg_typescCs|jS)N)r)rr%r/rrrr&sz(SharedPtrSubscriptWorker.get_result_typecCs|jS)N)rŽ)rrCrrrr’sz"SharedPtrSubscriptWorker._supportscCsZtjdt|jƒƒ}|rJ|t|jdƒƒkrJtd|jt|ƒt|jdƒƒfƒ‚tj||ƒ|S)Nz.*\[(\d+)]$r-z.shared_ptr<%s> index "%d" should not be >= %d.) rr rirr)Úgroupr0ršr')rr%r/r:rrrr's z!SharedPtrSubscriptWorker.__call__N) rrrr”rr$r&r’r'rrrrrœ srœc@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d„ZdS) ÚSharedPtrUseCountWorkerz*Implement std::shared_ptr::use_count().cCsdS)Nr)rr‘rrrr%sz SharedPtrUseCountWorker.__init__cCsdS)Nr)rrrrr$(sz%SharedPtrUseCountWorker.get_arg_typescCs tjdƒS)NZlong)rr)rr%rrrr&+sz'SharedPtrUseCountWorker.get_result_typecCsdS)NTr)rrCrrrr’.sz!SharedPtrUseCountWorker._supportscCs|dd}|r|dSdS)NZ_M_refcountZ_M_piZ_M_use_countrr)rr%Z refcountsrrrr'1sz SharedPtrUseCountWorker.__call__N) rrrr”rr$r&r’r'rrrrrž"sržc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚSharedPtrUniqueWorkerz'Implement std::shared_ptr::unique().cCstj||ƒdS)N)ržr)rr‘rrrr9szSharedPtrUniqueWorker.__init__cCs tjdƒS)Nr)rr)rr%rrrr&<sz%SharedPtrUniqueWorker.get_result_typecCstj||ƒdkS)Nr-)ržr')rr%rrrr'?szSharedPtrUniqueWorker.__call__N)rrrr”rr&r'rrrrrŸ6srŸc@seZdZdd„Zdd„ZdS)ÚSharedPtrMethodsMatchercsftjjjˆtdƒtdtƒtdtƒtdtƒtdtƒtdt ƒtdt ƒdœˆ_‡fd d „ˆjDƒˆ_dS)NÚ shared_ptrr?z operator->z operator*z operator[]Ú use_countÚunique)r?z operator->z operator*z operator[]r¢r£csg|]}ˆj|‘qSr)r8)r9r:)rrrr;Osz4SharedPtrMethodsMatcher.__init__..) rrr<rr=rršr›rœržrŸr8r>)rr)rrrDs z SharedPtrMethodsMatcher.__init__cCsPt|dƒsdS|jj|ƒ}|dks*|jr.dS|j|jdƒƒ}|j|ƒrL|SdS)Nr¡r)rr8r?r@rrAr’)rrBrCrDr™rrrr Qs zSharedPtrMethodsMatcher.matchN)rrrrr rrrrr Cs r cCstjj|tƒƒtjj|tƒƒtjj|tƒƒtjj|tƒƒtjj|tƒƒtjj|tdƒƒtjj|tdƒƒtjj|tdƒƒtjj|tdƒƒtjj|tdƒƒtjj|tdƒƒtjj|tdƒƒtjj|tdƒƒtjj|t ƒƒtjj|t ƒƒdS) NÚsetÚmapZmultisetZmultimapZ unordered_setZ unordered_mapZunordered_multisetZunordered_multimap)rrZregister_xmethod_matcherr2rgr[rrrrŠr—r )ZlocusrrrÚregister_libstdcxx_xmethods]s.r¦)>rZgdb.xmethodrr=rrrrrrrZ XMethodWorkerrr#r(r*r,r.r1r<r2rErRrSrTrUrXrZr[r]r`rcrgrjrnrorprqrrrtr{r|r}r~rr€rrƒrˆr‰rŠrŒr•r–r—ršr›rœržrŸr r¦rrrrÚsr * PKr1] ÇBö66=python/libstdcxx/v6/__pycache__/__init__.cpython-36.opt-1.pycnu„[µü¤3 À¡h}ã@sdd„Zdd„ZdS)cCs&yddl}dStk r dSXdS)NéTF)Zgdb.xmethodÚImportError)Zgdb©rú0/usr/share/gcc-8/python/libstdcxx/v6/__init__.pyÚgdb_has_xmethodss rcCs2ddlm}||ƒtƒr.ddlm}||ƒdS)Né)Úregister_libstdcxx_printers)Úregister_libstdcxx_xmethods)ZprintersrrZxmethodsr)Úobjrrrrrrs rN)rrrrrrÚsPKr1]3,Ïxexe7python/libstdcxx/v6/__pycache__/printers.cpython-36.pycnu„[µü¤3 À¡hõµã@säddlZddlZddlZddlZddlZddlZejddkrXeZe Z eZe ZejjZn6Gdd„dƒZddlm Z mZGdd„dejƒZeƒZdayddlZWnek r¶d aYnXd ayddlZeejd ƒrÖdaWnek rìYnXeedƒrejZneZdd „Zdadd„Zdd„Z dd„Z!dd„Z"dd„Z#dd„Z$dd„Z%dd„Z&Gdd „d eƒZ'Gd!d"„d"eƒZ(d#d$„Z)d%d&„Z*d'd(„Z+Gd)d*„d*eƒZ,d+d,„Z-d-d.„Z.Gd/d0„d0eƒZ/Gd1d2„d2eƒZ0Gd3d4„d4e0ƒZ1Gd5d6„d6e0ƒZ2Gd7d8„d8eƒZ3Gd9d:„d:eƒZ4Gd;d<„d„d>eƒZ6Gd?d@„d@eƒZ7GdAdB„dBeƒZ8GdCdD„dDeƒZ9GdEdF„dFeƒZ:GdGdH„dHeƒZ;dIdJ„ZdOdP„Z?GdQdR„dReƒZ@GdSdT„dTeƒZAGdUdV„dVeƒZBGdWdX„dXeƒZCGdYdZ„dZeƒZDGd[d\„d\eƒZEd]d^„ZFGd_d`„d`eƒZGGdadb„dbeƒZHGdcdd„ddeƒZIGdedf„dfeƒZJGdgdh„dheƒZKGdidj„djeƒZLGdkdl„dleƒZMGdmdn„dneƒZNdodp„ZOGdqdr„dreNƒZPGdsdt„dteNƒZQGdudv„dveNƒZRGdwdx„dxeNƒZSGdydz„dzeƒZTGd{d|„d|eƒZUGd}d~„d~eƒZVGdd€„d€eƒZWGdd‚„d‚eƒZXGdƒd„„d„eƒZYGd…d†„d†eƒZZGd‡dˆ„dˆeƒZ[Gd‰dŠ„dŠeƒZ\Gd‹dŒ„dŒeƒZ]GddŽ„dŽeƒZ^Gdd„deƒZ_Gd‘d’„d’eƒZ`Gd“d”„d”eƒZadd•d–d—d˜d™dšd›dœddždŸd g Zbd¡d¢d£d¤d¥d¦d§d¡gZcGd¨d©„d©eƒZdGdªd«„d«eƒZeGd¬d„deƒZfGd®d¯„d¯eƒZgGd°d±„d±eƒZhGd²d³„d³eƒZiGd´dµ„dµeƒZjGd¶d·„d·eƒZkGd¸d¹„d¹eƒZlGdºd»„d»eƒZmdanGd¼d½„d½eƒZod¾d¿„ZpGdÀdÁ„dÁeƒZqdÊdÂdÃ„ZrdÄdÅ„ZsdÆdÇ„ZtdÈdÉ„Zueuƒ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: cCs|jƒS)N)Ú__next__)Úself©rú0/usr/share/gcc-8/python/libstdcxx/v6/printers.pyÚnext?sz Iterator.nextN)Ú__name__Ú __module__Ú__qualname__Ú__doc__rrrrrr4s r)ÚimapÚizipc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚUTCz5Concrete tzinfo class representing the UTC time zone.cCs tjdƒS)Nr)ÚdatetimeÚ timedelta)rÚdtrrrÚ utcoffsetIsz UTC.utcoffsetcCsdS)Nrr)rrrrrÚtznameLsz UTC.tznamecCs tjdƒS)Nr)rr)rrrrrÚdstOszUTC.dstN)r r rrrrrrrrrrFsrTFZTypePrinterÚValuePrintercCsz|jƒ}xld|j|f}y tj|ƒStk r6YnX|jƒ}t|ƒr^|djr^|dj}q t dt |ƒ|fƒ‚q WdS)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_typens r%z__8::cGsdj|djdd„|Dƒƒƒ}y tj|ƒStjk rŠ}zFt|krv|jddtdƒ}y tj|ƒStjk rtYnX|‚WYdd}~XnXdS)z8 Lookup template specialization templ. z{}<{}>z, cSsg|]}t|ƒ‘qSr)r!)Ú.0Úarrrú ˆsz%lookup_templ_spec..z::éN)ÚformatÚjoinrrÚerrorÚ_versioned_namespaceÚreplace)ZtemplÚargsÚtÚerrrÚlookup_templ_spec„s r2cCs¬d|krd|}yt|dƒ}Wn|jdƒ}YnX|jƒ}y t||ƒStjk r¦t|dƒr¢t|dddƒr¢|jdd d ƒ}y t||ƒStjk r YnXdSXdS)a» Lookup specialization of template nodename corresponding to containertype. nodename - The name of a class template, as a String containertype - The container, as a gdb.Type Return a gdb.Type for the corresponding specialization of nodename, or None if the type cannot be found. e.g. lookup_node_type('_List_node', gdb.lookup_type('std::list')) will return a gdb.Type for the type std::_List_node. z::zstd::Ú value_typerZstdzstd::__cxx1998zstd::__debugZ__gnu_debugz ::__cxx1998::r)N)r%Útemplate_argumentrr2rr,Úis_member_of_namespacer.)ÚnodenameZ containertypeÚvaltyperrrÚlookup_node_type™s& r8cGs@t|tjƒrt|ƒ}t|ƒ}x|D]}|j|dƒr"dSq"WdS)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. z::TF)Ú isinstancerÚTyper!Ústrip_versioned_namespaceÚ startswith)r#Z namespacesÚ namespacerrrr5¾s r5cCs2t|tjƒr|j}dt|f}tjd||ƒdk S)zø Test whether a type is a specialization of the named class template. The type can be specified as a string or a gdb.Type object. The template should be the name of a class template as a string, without any 'std' qualification. z(%s)?%sz ^std::%s<.*>$N)r9rr:rr-ÚreÚmatch)ÚxÚ template_namerrrÚis_specialization_ofÌsrBcCs|jtdƒS)NÚ)r.r-)Útypenamerrrr;Úsr;cCs<d}d}tjddkr&tj|||dƒStj|||ddSdS)zCRemove "fundamentals_vN" inline namespace from qualified type name.z&^std::experimental::fundamentals_v\d::zstd::experimental::rrr))ÚcountN)ÚsysÚversion_infor>Úsub)r#ÚpatternÚreplrrrÚstrip_fundts_namespaceßs rKcCsVt|ƒ}|jddƒ}d}x d D]}|j||d|ƒ}qW|d}|j|d|ƒ}|S) zARemove known inline namespaces from the canonical name of a type.zstd::__cxx11::zstd::zstd::experimental::Úfundamentals_v1Úfundamentals_v2z::zfilesystem::zv1::)rLrM)r;r.)Útype_strZexpt_nsZlfts_nsZfs_nsrrrÚstrip_inline_namespacesés rOc Cs:d}g}x,y|j|j|ƒƒWn |S|d7}q WdS)z-Return a type's template arguments as a list.rr)N)Úappendr4)Útype_objÚnÚ template_argsrrrÚget_template_arg_listõsrTc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚSmartPtrIteratorz@An iterator for smart pointer types with a single 'child' value.cCs ||_dS)N)Ú_val)rÚvalrrrÚ__init__szSmartPtrIterator.__init__cCs|S)Nr)rrrrÚ__iter__szSmartPtrIterator.__iter__cCs$|jdkrt‚d|j|_}d|fS)Nzget())rVÚ StopIteration)rrWrrrr s zSmartPtrIterator.__next__N)r r rrrXrYrrrrrrUsrUc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)ÚSharedPointerPrinterzP Print a shared_ptr, weak_ptr, atomic, or atomic. cCst|ƒ|_||_|d|_dS)NÚ_M_ptr)r;Ú _typenamerVÚ_pointer)rrDrWrrrrXs zSharedPointerPrinter.__init__cCs t|jƒS)N)rUr^)rrrrÚchildrenszSharedPointerPrinter.childrencCsR|jdkrD|jddd}||d}t|jdjdƒ}|j|ƒS|jddS)Nzstd::atomicZ_M_refcountZ_M_valÚ_M_irÚpointerZ_M_pi)r]rVr%rÚcast)rZptr_valZptr_typerrrÚ_get_refcountss z#SharedPointerPrinter._get_refcountscCspd}|jƒ}|jjjdƒ}tt|ƒƒ}|dkr`|d}|d}|dkrPd|}nd||df}d|j||fS) NÚemptyrZ_M_use_countZ _M_weak_countzexpired, weak count %dzuse count %d, weak count %dr)z%s<%s> (%s))rcrVrr4r;r!r])rÚstateZ refcountsÚtargZusecountZ weakcountrrrÚ to_string(s zSharedPointerPrinter.to_stringN)r r rrrXr_rcrgrrrrr[s r[cCs¤|jjƒ}|djs&tdt|jƒƒ‚|j|djƒ}|jjƒ}t|ƒdkr^tdt|jƒƒ‚|djdkrt|dS|djrŽ|j|djƒStdt|jƒƒ‚dS)zBReturn the tuple element stored in a _Tuple_impl base class.r)z-Unsupported implementation for std::tuple: %srÚ_M_head_implNéÿÿÿÿri)rrrr r!rbrr")rWÚbasesZ head_baserrrrÚ_tuple_impl_get9s rkcCshtt|jƒƒ}||krtdƒ‚|j|jjƒdjƒ}x*|dkr^|j|jjƒdjƒ}|d8}q6Wt|ƒS)z6Return the result of std::get(val) on a std::tuple.z0Out of range index for std::get on std::tuplerr))rrTrr rbrrk)rRrWZ tuple_sizeÚnoderrrÚ tuple_getQs rmcCsd|jjƒdjjƒ}t|dƒs(t|dƒr6|dd}n$t|dƒrJ|d}ntdt|ƒƒ‚td|ƒS)z4Return the result of val.get() on a std::unique_ptr.rZ__uniq_ptr_dataZ__uniq_ptr_implÚ_M_tÚtuplez-Unsupported implementation for unique_ptr: %s)rrrrBr r!rm)rWZ impl_typeZtuple_memberrrrÚunique_ptr_get_s rpc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚUniquePointerPrinterzPrint a unique_ptr.cCs ||_dS)N)rV)rrDrWrrrrXtszUniquePointerPrinter.__init__cCstt|jƒƒS)N)rUrprV)rrrrr_wszUniquePointerPrinter.childrencCs|jjjdƒ}djt|ƒƒS)Nrzstd::unique_ptr<{}>)rVrr4r*r!)rr0rrrrgzszUniquePointerPrinter.to_stringN)r r rrrXr_rgrrrrrqqsrqcCs|djj|jƒƒjƒS)z7Return the value held in a __gnu_cxx::__aligned_membuf.Ú _M_storage)ÚaddressrbraÚdereference)Zbufr7rrrÚget_value_from_aligned_membufsruc CsjyF|jjƒdj}|dkr"|dS|dkrD|jjdƒ}t|d|ƒSWnYnXtdt|jƒƒ‚dS)z-Return the value held in an _List_node<_Val>.r)Ú_M_datarrrz!Unsupported implementation for %sN)rrr"r4rur r!)rlÚmemberr7rrrÚget_value_from_list_node„srxc@s8eZdZdZGdd„deƒZdd„Zdd„Zdd „Zd S)ÚStdListPrinterzPrint a std::list.c@s$eZdZdd„Zdd„Zdd„ZdS)zStdListPrinter._iteratorcCs"||_|d|_|j|_d|_dS)NÚ_M_nextr)Ú _nodetypeÚ_basersÚ_headÚ_count)rÚnodetypeÚheadrrrrX˜s z!StdListPrinter._iterator.__init__cCs|S)Nr)rrrrrYžsz!StdListPrinter._iterator.__iter__cCsR|j|jkrt‚|jj|jƒjƒ}|d|_|j}|jd|_t|ƒ}d||fS)Nrzr)z[%d])r|r}rZrbr{rtr~rx)rÚeltrErWrrrr¡s z!StdListPrinter._iterator.__next__N)r r rrXrYrrrrrÚ _iterator—sr‚cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX«s zStdListPrinter.__init__cCs(td|jjƒjƒ}|j||jddƒS)NÚ _List_nodeÚ_M_implÚ_M_node)r8rVrrar‚)rrrrrr_¯szStdListPrinter.childrencCs0|jdd}|d|jkr&d|jSd|jS)Nr„r…rzzempty %sz%s)rVrsr])rZheadnoderrrrg³s zStdListPrinter.to_stringN) r r rrrr‚rXr_rgrrrrry”s ryc@seZdZdd„Zdd„ZdS)ÚNodeIteratorPrintercCs$||_||_||_t||jƒ|_dS)N)rVr]Ú _contnamer8rr{)rrDrWZcontnamer6rrrrX»szNodeIteratorPrinter.__init__cCs:|jdsd|jS|jdj|jjƒƒjƒ}tt|ƒƒS)Nr…z(non-dereferenceable iterator for std::%s)rVr‡rbr{rartr!rx)rrlrrrrgÁs zNodeIteratorPrinter.to_stringN)r r rrXrgrrrrr†ºsr†c@seZdZdZdd„ZdS)ÚStdListIteratorPrinterzPrint std::list::iterator.cCstj|||ddƒdS)NÚlistrƒ)r†rX)rrDrWrrrrXÌszStdListIteratorPrinter.__init__N)r r rrrXrrrrrˆÉsrˆc@seZdZdZdd„ZdS)ÚStdFwdListIteratorPrinterz"Print std::forward_list::iterator.cCstj|||ddƒdS)NÚforward_listÚ_Fwd_list_node)r†rX)rrDrWrrrrXÓsz"StdFwdListIteratorPrinter.__init__N)r r rrrXrrrrrŠÐsrŠc@s8eZdZdZGdd„deƒZdd„Zdd„Zdd „Zd S)ÚStdSlistPrinterzPrint a __gnu_cxx::slist.c@s$eZdZdd„Zdd„Zdd„ZdS)zStdSlistPrinter._iteratorcCs||_|dd|_d|_dS)NÚ_M_headrzr)r{r|r~)rrr€rrrrXÜsz"StdSlistPrinter._iterator.__init__cCs|S)Nr)rrrrrYász"StdSlistPrinter._iterator.__iter__cCsL|jdkrt‚|jj|jƒjƒ}|d|_|j}|jd|_d||dfS)Nrrzr)z[%d]rv)r|rZrbr{rtr~)rrrErrrräs z"StdSlistPrinter._iterator.__next__N)r r rrXrYrrrrrr‚Ûsr‚cCs ||_dS)N)rV)rrDrWrrrrXíszStdSlistPrinter.__init__cCs td|jjƒ}|j|jƒ|jƒS)Nz__gnu_cxx::_Slist_node)r8rVrr‚ra)rrrrrr_ðszStdSlistPrinter.childrencCs|jdddkrdSdS)NrŽrzrzempty __gnu_cxx::slistz__gnu_cxx::slist)rV)rrrrrgôszStdSlistPrinter.to_stringN) r r rrrr‚rXr_rgrrrrrØs rc@s eZdZdZdd„Zdd„ZdS)ÚStdSlistIteratorPrinterz!Print __gnu_cxx::slist::iterator.cCs ||_dS)N)rV)rrDrWrrrrXýsz StdSlistIteratorPrinter.__init__cCs<|jdsdStd|jjƒjƒ}t|jdj|ƒjƒdƒS)Nr…z1non-dereferenceable iterator for __gnu_cxx::slistz__gnu_cxx::_Slist_noderv)rVr8rrar!rbrt)rrrrrrgs z!StdSlistIteratorPrinter.to_stringN)r r rrrXrgrrrrrúsrc@s@eZdZdZGdd„deƒZdd„Zdd„Zdd „Zd d„Z dS) ÚStdVectorPrinterzPrint a std::vector.c@s$eZdZdd„Zdd„Zdd„ZdS)zStdVectorPrinter._iteratorcCs^||_|rH|d|_d|_|d|_|d|_|jjƒj}d|j|_n||_||_d|_ dS)NÚ_M_prÚ _M_offseté) Ú_bitvecÚ_itemÚ_soÚ_finishÚ_fortrÚsizeofÚ_isizer~)rÚstartÚfinishZbitvecÚityperrrrXs z#StdVectorPrinter._iterator.__init__cCs|S)Nr)rrrrrYsz#StdVectorPrinter._iterator.__iter__cCs¸|j}|jd|_|jr‚|j|jkr4|j|jkr4t‚t|jjƒd|j>@ƒ}|jd|_|j|j krv|jd|_d|_d||fS|j|jkr’t‚|jjƒ}|jd|_d||fSdS)Nr)rz[%d]) r~r”r•r—r–r˜rZÚboolrtrš)rrErrrrrs z#StdVectorPrinter._iterator.__next__N)r r rrXrYrrrrrr‚sr‚cCs*t|ƒ|_||_|jjdƒjtjk|_dS)Nr) r;r]rVrr4ÚcoderÚTYPE_CODE_BOOLÚ_is_bool)rrDrWrrrrX0s zStdVectorPrinter.__init__cCs$|j|jdd|jdd|jƒS)Nr„Ú_M_startÚ _M_finish)r‚rVr¡)rrrrr_6szStdVectorPrinter.childrenc CsÒ|jdd}|jdd}|jdd}|jr®|jddd}|jddd}|jddd}|jƒj}d|j}||||}|||}d|jt|ƒt|ƒfSd |jt||ƒt||ƒfSdS) Nr„r¢r£Z_M_end_of_storager‘r’r“z"%s of length %d, capacity %dz%s of length %d, capacity %d)rVr¡rtrr™r]Úint) rr›rœÚendZforZblÚlengthZcapacityrrrrg;s zStdVectorPrinter.to_stringcCsdS)NÚarrayr)rrrrÚdisplay_hintMszStdVectorPrinter.display_hintN) r r rrrr‚rXr_rgr¨rrrrrs%rc@s eZdZdZdd„Zdd„ZdS)ÚStdVectorIteratorPrinterzPrint std::vector::iterator.cCs ||_dS)N)rV)rrDrWrrrrXTsz!StdVectorIteratorPrinter.__init__cCs |jdsdSt|jdjƒƒS)NZ _M_currentz,non-dereferenceable iterator for std::vector)rVr!rt)rrrrrgWs z"StdVectorIteratorPrinter.to_stringN)r r rrrXrgrrrrr©Qsr©c@s eZdZdZdd„Zdd„ZdS)ÚStdBitIteratorPrinterz@Print std::vector's _Bit_iterator and _Bit_const_iterator.cCs ||_dS)N)rV)rrDrWrrrrX`szStdBitIteratorPrinter.__init__cCs.|jdsdSt|jdjƒd|jd>@ƒS)Nr‘z2non-dereferenceable iterator for std::vectorr)r’)rVržrt)rrrrrgcs zStdBitIteratorPrinter.to_stringN)r r rrrXrgrrrrrª]srªc@s eZdZdZdd„Zdd„ZdS)ÚStdBitReferencePrinterz#Print std::vector::reference.cCs ||_dS)N)rV)rrDrWrrrrXmszStdBitReferencePrinter.__init__cCs*|jdsdSt|jdjƒ|jd@ƒS)Nr‘z$invalid std::vector::referenceZ_M_mask)rVržrt)rrrrrgps z StdBitReferencePrinter.to_stringN)r r rrrXrgrrrrr«jsr«c@s8eZdZdZGdd„deƒZdd„Zdd„Zdd „Zd S)ÚStdTuplePrinterzPrint a std::tuple.c@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.)rrBrr )ÚnodesrrrÚ_is_nonempty_tuple}sz,StdTuplePrinter._iterator._is_nonempty_tuplecCs:||_|jjjƒ}|j|ƒr0|jj|djƒ|_d|_dS)Nr)r}rrr®rbr~)rr€rrrrrX‰s z"StdTuplePrinter._iterator.__init__cCs|S)Nr)rrrrrY”sz"StdTuplePrinter._iterator.__iter__cCsâ|js t‚|jjjƒ}t|ƒdkr&t‚t|ƒdkr:tdƒ‚t|ƒdkr`|jj|djƒ}d|_n&|jj|djƒ}|jj|djƒ|_|jd|_|jjƒ}t|ƒdks¶|djdkrÈd|jd|fSd|jd|dfSdS)Nrrz/Cannot parse more than 2 nodes in a tuple tree.r)rhz[%d]) r}rZrrrr rbr~r")rrÚimplrrrrr—s$ z"StdTuplePrinter._iterator.__next__N)r r rÚstaticmethodr®rXrYrrrrrr‚|sr‚cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrXÁs zStdTuplePrinter.__init__cCs|j|jƒS)N)r‚rV)rrrrr_ÅszStdTuplePrinter.childrencCs(t|jjjƒƒdkrd|jSd|jS)Nrzempty %sz %s containing)rrVrrr])rrrrrgÈs zStdTuplePrinter.to_stringN) r r rrrr‚rXr_rgrrrrr¬ys Er¬c@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)ÚStdStackOrQueuePrinterz!Print a std::stack or std::queue.cCst|ƒ|_tj|dƒ|_dS)NÚc)r;r]rÚdefault_visualizerÚ_visualizer)rrDrWrrrrXÑs zStdStackOrQueuePrinter.__init__cCs |jjƒS)N)r´r_)rrrrr_ÕszStdStackOrQueuePrinter.childrencCsd|j|jjƒfS)Nz%s wrapping: %s)r]r´rg)rrrrrgØsz StdStackOrQueuePrinter.to_stringcCst|jdƒr|jjƒSdS)Nr¨)Úhasattrr´r¨)rrrrr¨Üs z#StdStackOrQueuePrinter.display_hintN)r r rrrXr_rgr¨rrrrr±Îs 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)Nrnr„Z _M_node_countZ _M_headerÚ_M_leftr)Ú_sizeÚ_noder~)rZrbtreerrrrXèszRbtreeIterator.__init__cCs|S)Nr)rrrrrYíszRbtreeIterator.__iter__cCs t|jƒS)N)r¤r¸)rrrrÚ__len__ðszRbtreeIterator.__len__cCs¼|j|jkrt‚|j}|jd|_|j|jkr¸|j}|jƒdrl|jƒd}xd|jƒdrh|jƒd}qNWnF|jƒd}x$||jƒdkrœ|}|jƒd}qzW|jƒd|kr²|}||_|S)Nr)Z_M_rightr·Z _M_parent)r~r¸rZr¹rt)rÚresultrlÚparentrrrrós$zRbtreeIterator.__next__N)r r rrrXrYrºrrrrrr¶âs r¶c CsjyF|jjƒdj}|dkr"|dS|dkrD|jjdƒ}t|d|ƒSWnYnXtdt|jƒƒ‚dS)z0Return the value held in an _Rb_tree_node<_Val>.r)Z_M_value_fieldrrrz!Unsupported implementation for %sN)rrr"r4rur r!)rlrwr7rrrÚget_value_from_Rb_tree_node sr½c@s eZdZdZdd„Zdd„ZdS)ÚStdRbtreeIteratorPrinterz2Print std::map::iterator, std::set::iterator, etc.cCs"||_td|jjƒ}|jƒ|_dS)NÚ _Rb_tree_node)rVr8rraÚ _link_type)rrDrWrrrrrX!sz!StdRbtreeIteratorPrinter.__init__cCs0|jdsdS|jdj|jƒjƒ}tt|ƒƒS)Nr…z6non-dereferenceable iterator for associative container)rVrbrÀrtr!r½)rrlrrrrg&s z"StdRbtreeIteratorPrinter.to_stringN)r r rrrXrgrrrrr¾sr¾c@s eZdZdZdd„Zdd„ZdS)ÚStdDebugIteratorPrinterz-Print a debug enabled version of an iterator.cCs ||_dS)N)rV)rrDrWrrrrX0sz StdDebugIteratorPrinter.__init__cCsbtjdƒ}|jjjdƒ}|jj|ƒd}|std|ƒ|_nd|_dS)Nrir)) r;r]rVrr4Z_elttyper™r¤r×)rrDrWÚsizerrrrXãs 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_firstz %s with %s)rVr×r]rÃÚlong)rr›r¥Zdelta_nZdelta_sZdelta_erÚrrrrgíszStdDequePrinter.to_stringcCs@|jdd}|jdd}|j|d|d|d|d|jƒS)Nr„r¢r£r…rÜrÛ)rVrËr×)rr›r¥rrrr_ùszStdDequePrinter.childrencCsdS)Nr§r)rrrrr¨ÿszStdDequePrinter.display_hintN) r r rrrrËrXrgr_r¨rrrrrÓÂs rÓc@s eZdZdZdd„Zdd„ZdS)ÚStdDequeIteratorPrinterzPrint std::deque::iterator.cCs ||_dS)N)rV)rrDrWrrrrXsz StdDequeIteratorPrinter.__init__cCs |jdsdSt|jdjƒƒS)NrÜz+non-dereferenceable iterator for std::deque)rVr!rt)rrrrrg s z!StdDequeIteratorPrinter.to_stringN)r r rrrXrgrrrrrßsrßc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚStdStringPrinterz'Print a std::basic_string of some kind.cCs||_|jdƒdk|_dS)Nz::__cxx11::basic_stringr)ri)rVÚfindÚ_new_string)rrDrWrrrrXszStdStringPrinter.__init__cCsª|jj}|jtjkr|jƒ}|jdd}|jrL|jd}|j|jjƒƒ}n<|j ƒjƒ}tj t|ƒdƒjƒ}|j|ƒd}|j ƒd}t|dƒrž|j|dS|j|dS) NZ_M_dataplusr‘Z_M_string_lengthz::_Repr)Z _M_lengthÚlazy_string)r¦)rVrrŸrÚ TYPE_CODE_REFrÐrârbrÚunqualifiedrr!rartrµrãÚstring)rrÚptrr¦ZrealtypeZreptypeÚheaderrrrrgs zStdStringPrinter.to_stringcCsdS)Nrær)rrrrr¨-szStdStringPrinter.display_hintN)r r rrrXrgr¨rrrrràsràcCs"|d}|d}|d}|||fS)z'Access the streambuf put area pointers.Z _M_out_begZ _M_out_curZ _M_in_endr)Ú streambufÚpbaseÚpptrÚegptrrrrÚaccess_streambuf_ptrs1sríc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚStdStringBufPrinterzPrint a std::basic_stringbuf.cCs ||_dS)N)rV)rÚ_rWrrrrX<szStdStringBufPrinter.__init__cCsLt|jƒ\}}}|rB|s"||kr2|j||dS|j||dS|jdS)N)r¦Z _M_string)rírVræ)rrêrërìrrrrg?szStdStringBufPrinter.to_stringcCsdS)Nrær)rrrrr¨Isz StdStringBufPrinter.display_hintN)r r rrrXrgr¨rrrrrî9s rîc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚStdStringStreamPrinterz Print a std::basic_stringstream.cCsZ||_||_dd„|jjƒDƒd}tjd|j|ƒjƒtjdƒ|_ |j |djk|_ dS)NcSsg|]}|jr|j‘qSr)rr)r&Úfrrrr(Xsz3StdStringStreamPrinter.__init__..rZ__streamz$__stream->rdbuf()Ú_M_stringbuf)rVr]rrrZset_convenience_variablerbrsÚparse_and_evalÚ _streambufÚ_was_redirected)rrDrWZbasetyperrrrXPszStdStringStreamPrinter.__init__cCs$|jrd|j|jjƒfS|jdS)Nz%s redirected to %srò)rõr]rôrtrV)rrrrrg]sz StdStringStreamPrinter.to_stringcCs|jr dSdS)Nræ)rõ)rrrrr¨csz#StdStringStreamPrinter.display_hintN)r r rrrXrgr¨rrrrrðMs rðc@s$eZdZdd„Zdd„Zdd„ZdS)ÚTr1HashtableIteratorcCsj|d|_d|_|d|_t|jdƒjƒ|_d|_x2|j|jkrd|j|j|_|jrVP|jd|_q4WdS)NZ _M_bucketsrZ_M_bucket_countZ_Noder))Ú_bucketsÚ_bucketÚ _bucket_countr%rraÚ _node_typer¹)rÚ hashtablerrrrXjs zTr1HashtableIterator.__init__cCs|S)Nr)rrrrrYvszTr1HashtableIterator.__iter__cCs„|jdkrt‚|jj|jƒ}|jƒd}|jƒd|_|jdkr€|jd|_x2|j|jkr~|j|j|_|jrpP|jd|_qNW|S)NrZ_M_vrzr))r¹rZrbrúrtrørùr÷)rrlr»rrrrys zTr1HashtableIterator.__next__N)r r rrXrYrrrrrröisröc@s$eZdZdd„Zdd„Zdd„ZdS)ÚStdHashtableIteratorcCsR|dd|_|jjdƒ}|jjdƒjdƒ}tdt|ƒ|r>dndƒ}|jƒ|_dS) NZ_M_before_beginÚ_M_nxtr)é rzstd::__detail::_Hash_nodeÚtrueZfalse)r¹rr4r2r!rarú)rrûr7ÚcachedZ node_typerrrrXŠs zStdHashtableIterator.__init__cCs|S)Nr)rrrrrY’szStdHashtableIterator.__iter__cCsR|jdkrt‚|jj|jƒjƒ}|d|_|dj}|j|jjdƒjƒƒ}|jƒS)Nrrýrr) r¹rZrbrúrtrsrr4ra)rrÚvalptrrrrr•s zStdHashtableIterator.__next__N)r r rrXrYrrrrrrü‰srüc@s<eZdZdZdd„Zdd„Zdd„Zedd „ƒZd d„Z dS) ÚTr1UnorderedSetPrinterz1Print a std::unordered_set or tr1::unordered_set.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX¢s zTr1UnorderedSetPrinter.__init__cCs|jjdƒr|jS|jdS)Nzstd::tr1Ú_M_h)r]r<rV)rrrrÚ _hashtable¦sz!Tr1UnorderedSetPrinter._hashtablecCs|jƒd}d|jt|ƒfS)NÚ_M_element_countz %s with %s)rr]rÃ)rrErrrrg«sz Tr1UnorderedSetPrinter.to_stringcCsd|S)Nz[%d]r)ÚirrrÚ _format_count¯sz$Tr1UnorderedSetPrinter._format_countcCs@t|jtjƒƒ}|jjdƒr.t|t|jƒƒƒSt|t |jƒƒƒS)Nzstd::tr1) r rÚ itertoolsrEr]r<rrörrü)rÚcounterrrrr_³szTr1UnorderedSetPrinter.childrenN) r r rrrXrrgr°rr_rrrrrŸsrc@s\eZdZdZdd„Zdd„Zdd„Zedd „ƒZed d„ƒZ edd „ƒZ dd„Zdd„ZdS)ÚTr1UnorderedMapPrinterz1Print a std::unordered_map or tr1::unordered_map.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX½s zTr1UnorderedMapPrinter.__init__cCs|jjdƒr|jS|jdS)Nzstd::tr1r)r]r<rV)rrrrrÁsz!Tr1UnorderedMapPrinter._hashtablecCs|jƒd}d|jt|ƒfS)Nrz %s with %s)rr]rÃ)rrErrrrgÆsz Tr1UnorderedMapPrinter.to_stringccs&x |D]}x|D] }|VqWqWdS)Nr)r‰rrrrrÚ_flattenÊs zTr1UnorderedMapPrinter._flattencCs|d|dfS)NrÈrÉr)rrrrÚ_format_oneÐsz"Tr1UnorderedMapPrinter._format_onecCsd|S)Nz[%d]r)rrrrrÔsz$Tr1UnorderedMapPrinter._format_countcCsdt|jtjƒƒ}|jjdƒr@|jt|jt|j ƒƒƒƒ}t ||ƒS|jt|jt|j ƒƒƒƒ}t ||ƒS)Nzstd::tr1)r rrrEr]r<rrrörrrü)rr Údatarrrr_Øs zTr1UnorderedMapPrinter.childrencCsdS)NrÌr)rrrrr¨åsz#Tr1UnorderedMapPrinter.display_hintN) r r rrrXrrgr°rrrr_r¨rrrrr ºs r c@s8eZdZdZGdd„deƒZdd„Zdd„Zdd „Zd S)ÚStdForwardListPrinterzPrint a std::forward_list.c@s$eZdZdd„Zdd„Zdd„ZdS)zStdForwardListPrinter._iteratorcCs||_|d|_d|_dS)Nrzr)r{r|r~)rrr€rrrrXís z(StdForwardListPrinter._iterator.__init__cCs|S)Nr)rrrrrYòsz(StdForwardListPrinter._iterator.__iter__cCsl|jdkrt‚|jj|jƒjƒ}|d|_|j}|jd|_|dj}|j|jjdƒj ƒƒ}d||jƒfS)Nrrzr)rrz[%d]) r|rZrbr{rtr~rsrr4ra)rrrErrrrrõs z(StdForwardListPrinter._iterator.__next__N)r r rrXrYrrrrrr‚ìsr‚cCs||_t|ƒ|_dS)N)rVr;r])rrDrWrrrrXszStdForwardListPrinter.__init__cCs(td|jjƒjƒ}|j||jddƒS)NrŒr„rŽ)r8rVrrar‚)rrrrrr_szStdForwardListPrinter.childrencCs*|jddddkr d|jSd|jS)Nr„rŽrzrzempty %sz%s)rVr])rrrrrgs zStdForwardListPrinter.to_stringN) r r rrrr‚rXr_rgrrrrrés rc@sBeZdZdZd dd„Zdd„ZGdd„deƒZd d „Zdd„Z dS)ÚSingleObjContainerPrinterz8Base class for printers of containers of single objects.NcCs||_||_||_dS)N)Ú_contained_valuer´Ú_hint)rrWZvizZhintrrrrXsz"SingleObjContainerPrinter.__init__cCs(tst|ƒStjjtjjƒ|ƒp&t|ƒS)z5Return type as a string after applying type printers.)Ú_use_type_printingr!rÚtypesÚapply_type_recognizersÚget_type_recognizers)rrrrrÚ _recognizesz$SingleObjContainerPrinter._recognizec@s$eZdZdd„Zdd„Zdd„ZdS)z$SingleObjContainerPrinter._containedcCs ||_dS)N)rV)rrWrrrrXsz-SingleObjContainerPrinter._contained.__init__cCs|S)Nr)rrrrrY"sz-SingleObjContainerPrinter._contained.__iter__cCs"|jdkrt‚|j}d|_d|fS)Nz[contained value])rVrZ)rZretvalrrrr%s z-SingleObjContainerPrinter._contained.__next__N)r r rrXrYrrrrrÚ _containedsrcCs6|jdkr|jdƒSt|jdƒr*|jjƒS|j|jƒS)Nr_)rrrµr´r_)rrrrr_,s z"SingleObjContainerPrinter.childrencCs(t|jdƒr"t|jdƒr"|jjƒS|jS)Nr_r¨)rµr´r¨r)rrrrr¨3s z&SingleObjContainerPrinter.display_hint)N) r r rrrXrrrr_r¨rrrrrs rc CsH|jƒj}tjddkr"t|ƒ}nt|ƒ}ytj|ƒjj SdSdS)z{Find the name of the function referred to by the gdb.Value f, which should contain a function pointer from the program.rrN) rtrsrFrGrÞr¤rZblock_for_pcÚfunctionr")rñrrrÚfunction_pointer_to_name;s rcs4eZdZdZ‡fdd„Zdd„Zedd„ƒZ‡ZS)ÚStdExpAnyPrinterz+Print a std::any or std::experimental::any.csœt|ƒ|_t|jƒ|_||_d|_d}d}|jd}|dkr†t|ƒ}|sXtd|jƒ‚dj|ƒ}tj ||ƒ}|s€td|jƒ‚|j dƒ} d| kr g} xPtjƒD]D}y(tj d||j dƒƒ}| jtj|ƒƒWq¢tjk räYq¢Xq¢Wt| ƒdkrtd ƒ‚| d} n tj| ƒ} | jdƒ|_d}d | kr@|jddj}n(d | krZ|jdd}ntd|jƒ‚|j|jjƒƒjƒ}tj|ƒ}tt|ƒj||ƒdS)NZ _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 %sr)zstd::stringzstd::string(?!\w)z;Cannot uniquely determine std::string type used in std::anyz::_Manager_internalrrZ _M_bufferz::_Manager_externalr\)r;r]rKrVÚ_contained_typerr r*r>r?ÚgrouprÚ _string_typesrHrPrrr,rr4rsrbrartr³ÚsuperrX)rrDrWÚcontained_valueÚ visualizerZmgrÚfuncZrxÚmZmgrnameZmgrtypesÚsr@Zmgrtyper)Ú __class__rrrXVsX zStdExpAnyPrinter.__init__cCsT|jdkrd|jSd|j}t|jdƒr8||jjƒS|j|jƒ}|tt|ƒƒS)Nz%s [no contained value]z%s containing r_)rr]rµr´rgrr;r!)rÚdescr7rrrrgšs zStdExpAnyPrinter.to_stringcs@ttjdƒjƒƒh}d‰dddtg}|‡fdd„|DƒO}|S)Nzstd::stringzAbasic_string, std::allocator >zstd::zstd::__cxx11::csh|]}|ˆ’qSrr)r&Úq)r#rrú sz1StdExpAnyPrinter._string_types..)r!rrrr-)ZstringsZqualsr)r#rr£s zStdExpAnyPrinter._string_types) r r rrrXrgr°rÚ __classcell__rr)r$rrSsD rcs(eZdZdZ‡fdd„Zdd„Z‡ZS)ÚStdExpOptionalPrinterz5Print a std::optional or std::experimental::optional.c sŠt|ƒ|_t|jƒ|_|d}|jjdƒr8|d}|}n*|d}|d}y|d}WnYnXtj|ƒ}|std}tt|ƒj||ƒdS)NÚ _M_payloadzstd::experimentalÚ _M_engagedÚ_M_value) r;r]rKr<rr³rr)rX)rrDrWZpayloadZengagedrr )r$rrrX´s" zStdExpOptionalPrinter.__init__cCs:|jdkrd|jSt|jdƒr4d|j|jjƒfS|jS)Nz%s [no contained value]r_z%s containing %s)rr]rµr´rg)rrrrrgÉs zStdExpOptionalPrinter.to_string)r r rrrXrgr(rr)r$rr)±sr)cs(eZdZdZ‡fdd„Zdd„Z‡ZS)ÚStdVariantPrinterzPrint a std::variant.cs”t|jƒ}t|ƒ|_|d|_|jt|ƒkrz[%s])r•r—rZrtr~r7r@r=)rrÊrEr?r0rrrrRs z$StdExpPathPrinter._iterator.__next__N)r r rrXrYrrrrrr‚Hsr‚cCs|j|jd|jƒS)Nr8)r‚rVr])rrrrr__szStdExpPathPrinter.childrenN) r r rrrXr=rgrr‚r_rrrrr7.sr7c@s@eZdZdZdd„Zdd„Zdd„ZGdd „d eƒZd d„Z dS) ÚStdPathPrinterzPrint a std::filesystem::path.cCsP||_||_t|jddƒ}|jtjdƒƒd@|_|jdkrF||_nd|_dS)Nr8r„Z uintptr_tér)rVr]rprbrrrÆÚ_impl)rrDrWr¯rrrrXfs zStdPathPrinter.__init__cCsHt|jjtj|jdƒƒƒ}|dd…dkr0dS|d d…dkrDdSdS) Nz::_Typerþr:zroot-directoryr;r<z root-namei÷ÿÿÿiöÿÿÿ)r!rÆrbrrr])rr0rrrr=pszStdPathPrinter._path_typecCs8d|jd}|jdkr0|jƒ}|r0d||f}d|S)Nz%sr>rz%s [%s]zfilesystem::path %s)rVrÆr=)rr?r0rrrrgxs zStdPathPrinter.to_stringc@s$eZdZdd„Zdd„Zdd„ZdS)zStdPathPrinter._iteratorc Cs²||_|r¢tjdƒ}tj|dƒ}tjdƒ}|j|jƒƒ}|jƒ}ttjdƒrbtd|j |j ƒ}n d|j }|j|jƒƒ|}|j|jƒƒ|_|j||_d|_ nd|_d|_dS)Nr¤z::_CmptÚcharÚalignofrr)r@rrrbrartrµr:Úmaxr™rFr•r—r~) rr¯rAZint_typeZ cmpt_typeÚ char_typerÚZsizeof_ImplÚbeginrrrrXs z!StdPathPrinter._iterator.__init__cCs|S)Nr)rrrrrY˜sz!StdPathPrinter._iterator.__iter__cCsd|j|jkrt‚|jjƒ}|j}|jd|_|jd|_|d}t|j|ƒjƒ}|sX|}d||fS)Nr)r>z[%s])r•r—rZrtr~rBr@r=)rrÊrEr?r0rrrr›s z!StdPathPrinter._iterator.__next__N)r r rrXrYrrrrrr‚€sr‚cCs|j|j|jƒS)N)r‚rDr])rrrrr_¨szStdPathPrinter.childrenN) r r rrrXr=rgrr‚r_rrrrrBcs (rBc@s8eZdZdZdd„ZGdd„deƒZdd„Zdd „Zd S)ÚStdPairPrinterz@Print a std::pair object, with 'first' and 'second' as children.cCs ||_dS)N)rV)rrDrWrrrrX¯szStdPairPrinter.__init__c@s(eZdZdZdd„Zdd„Zdd„ZdS) zStdPairPrinter._iterz?An iterator for std::pair types. Returns 'first' then 'second'.cCs||_d|_dS)NrÈ)rVÚ_which)rrWrrrrXµszStdPairPrinter._iter.__init__cCs|S)Nr)rrrrrY¹szStdPairPrinter._iter.__iter__cCs8|jdkrt‚|j}|dkr$d|_nd|_||j|fS)NrÈrÉ)rKrZrV)rZwhichrrrr¼s zStdPairPrinter._iter.__next__N)r r rrrXrYrrrrrrË²srËcCs|j|jƒS)N)rËrV)rrrrr_ÆszStdPairPrinter.childrencCsdS)Nr)rrrrrgÉszStdPairPrinter.to_stringN) r r rrrXrrËr_rgrrrrrJ¬s rJc@s eZdZdZdd„Zdd„ZdS)ÚStdCmpCatPrinterz#Print a comparison category object.cCs&||jdƒdd…|_|d|_dS)Nú:r)r,)Úrfindr]rV)rrDrWrrrrXÐszStdCmpCatPrinter.__init__cCsJ|jdkr|jdkrd}n"dddddddd i}|t|jƒ}d j|j|ƒS)NÚstrong_orderingrZequalrZ unorderedr)ZlessZ equivalentZgreaterzstd::{}::{}ri)r]rVr¤r*)rr"ÚnamesrrrrgÔs zStdCmpCatPrinter.to_stringN)r r rrrXrgrrrrrLÍsrLc@s`eZdZdZdZdd„Zedd„ƒZedd„ƒZ ed d „ƒZ edd„ƒZed d„ƒZdd„Z dS)ÚStdErrorCodePrinterz0Print a std::error_code or std::error_condition.NcCsL||_t|ƒ|_tjdkrHyddl}dt_Wntk rFdt_YnXdS)NrTF)rVr;r]rQÚ_system_is_posixÚposixÚImportError)rrDrWrSrrrrXâs zStdErrorCodePrinter.__init__cCs&tj|ƒ}|dk r"|jtjkr"|SdS)N)rrrŸZTYPE_CODE_ENUM)r"r#rrrÚ_find_errc_enumís z#StdErrorCodePrinter._find_errc_enumcCsBxs( zStdErrorCodePrinter.to_string)r r rrrRrXr°rUÚclassmethodrXr]rdrfrgrrrrrQÝs +rQc@s eZdZdZdd„Zdd„ZdS)ÚStdRegexStatePrinterz/Print a state node in the NFA for a std::regex.cCs||_||_dS)N)rVr])rrDrWrrrrX[szStdRegexStatePrinter.__init__cCs–t|jdƒ}|r|dd…}|jd}ddddddddddddddœ }||}d j||ƒ}|dk rŽ|jd |dk rŽdj|||jd |ƒ}d|S) NZ _M_opcodeérzZaltZsubexprÚnegZ backref_index) ÚrepeatÚalternativeZ subexpr_beginZsubexpr_endZline_begin_assertionZline_end_assertionZ word_boundaryZsubexpr_lookaheadZbackrefr?ZacceptZdummyÚunknownzopcode={}, next={}Z_M_z {}, {}={}z{%s})r!rVr*)rZopcodeZnext_idZvariantsÚvr#rrrrg_s zStdRegexStatePrinter.to_stringN)r r rrrXrgrrrrrlXsrlc@s@eZdZdZGdd„deƒZdd„Zdd„Zdd „Zd d„Z dS) ÚStdSpanPrinterzPrint a std::span.c@s$eZdZdd„Zdd„Zdd„ZdS)zStdSpanPrinter._iteratorcCsd|_||_||_dS)Nr)r~Ú_beginr¸)rrIrÚrrrrXysz!StdSpanPrinter._iterator.__init__cCs|S)Nr)rrrrrY~sz!StdSpanPrinter._iterator.__iter__cCs8|j|jkrt‚|j}|jd|_d||j|jƒfS)Nr)z[%d])r~r¸rZrtrt)rrErrrrs z!StdSpanPrinter._iterator.__next__N)r r rrXrYrrrrrr‚xsr‚cCsLt|ƒ|_||_tjdƒ}|jjdƒ|kr:|dd|_n|jjdƒ|_dS)Nzstatic_cast(-1)r)Z _M_extentZ_M_extent_value)r;r]rVrrórr4r¸)rrDrWZsize_maxrrrrX‰s zStdSpanPrinter.__init__cCsd|j|jfS)Nz%s of length %d)r]r¸)rrrrrg’szStdSpanPrinter.to_stringcCs|j|jd|jƒS)Nr\)r‚rVr¸)rrrrr_•szStdSpanPrinter.childrencCsdS)Nr§r)rrrrr¨˜szStdSpanPrinter.display_hintN) r r rrrr‚rXrgr_r¨rrrrrsus rsc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)ÚStdInitializerListPrinterzPrint a std::initializer_list.cCs||_||_|d|_dS)Nr6)r]rVr¸)rrDrWrrrrXŸsz"StdInitializerListPrinter.__init__cCsd|j|jfS)Nz%s of length %d)r]r¸)rrrrrg¤sz#StdInitializerListPrinter.to_stringcCstj|jd|jƒS)NZ_M_array)rsr‚rVr¸)rrrrr_§sz"StdInitializerListPrinter.childrencCsdS)Nr§r)rrrrr¨ªsz&StdInitializerListPrinter.display_hintN)r r rrrXrgr_r¨rrrrruœs ruc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚStdAtomicPrinterzPrint a std:atomic.cCsrt|ƒ|_||_d|_|jjjdƒ|_|jjdk rnt|jjƒ}|jdƒsR|jdƒrn|d}t ||ƒ|_|j |_dS)Nrzstd::shared_ptr = { %s })rwrgr1rŸrZ TYPE_CODE_INTrVÚ TYPE_CODE_FLTÚ TYPE_CODE_PTRr r]r!)rrWrrrrgÁs zStdAtomicPrinter.to_stringN)r r rrrXrxrgrrrrrv®s rvc@s eZdZdZdd„Zdd„ZdS)ÚStdFormatArgsPrinterzPrint a std::basic_format_args.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX×s zStdFormatArgsPrinter.__init__cCs€t|jjƒ}t|dƒd}|tjdƒkr0d}n|tjdƒkrDd}nd}|jd}|dkrbd |S|dkrt|jd }d||fS)Nrr)rEzstd::format_argsÚwchar_tzstd::wformat_argszstd::basic_format_argsZ_M_packed_sizez%s with 1 argumentZ_M_unpacked_sizez%s with %d arguments)rTrVrrr)rZtargsrHr#rÚrrrrgÛs zStdFormatArgsPrinter.to_stringN)r r rrrXrgrrrrr{Òsr{c@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)ÚStdChronoDurationPrinterzPrint a std::chrono::duration.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrXðs z!StdChronoDurationPrinter.__init__cCs*|jjjdƒ}|jdƒ}|jdƒ}||fS)Nr)r)rVrr4)rZperiodrÂÚdenrrrÚ_ratioôs zStdChronoDurationPrinter._ratiocCsˆ|jƒ\}}|dkrF|dkr dS|dkr,dS|dkr8dS|dkr|dSn6|dkr||d krZd S|dkrfdS|d krrdSdj|ƒSdj||ƒS)Nr)r#ièZmsi@BÚusiÊš;rWé<ÚminiÚhi€QÚdz[{}]sz[{}/{}]s)rr*)rrÂr~rrrÚ_suffixûs& z StdChronoDurationPrinter._suffixcCs4|jd}|jjƒjtjkr$d|}dj||jƒƒS)NÚ__rz%gz"std::chrono::duration = {{ {}{} }})rVrrrŸrryr*r…)rÚrrrrrgs z"StdChronoDurationPrinter.to_stringN)r r rrrXrr…rgrrrrr}ís r}c@s*eZdZdZdd„Zdd„Zd dd„Zd S)ÚStdChronoTimePointPrinterz Print a std::chrono::time_point.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrXs z"StdChronoTimePointPrinter.__init__cCsv|jjjdƒ}t|jƒ}|dks(|dkr,dS|dkr8dS|dkrDdS|d krPdS|dkr\dS|dkrhdSdj|ƒdfS)Nrzstd::chrono::_V2::system_clockzstd::chrono::system_clockústd::chrono::sys_timezstd::chrono::utc_clockústd::chrono::utc_timezstd::chrono::gps_clockústd::chrono::gps_timezstd::chrono::tai_clockústd::chrono::tai_timezstd::filesystem::__file_clockústd::chrono::file_timeìumzstd::chrono::local_tústd::chrono::local_timez {} time_point)r‰r)rŠN)r‹N)rŒN)rrŽ)rr)rVrr4r;r"r*)rÚclockr"rrrÚ_clocks z StdChronoTimePointPrinter._clockFc Cs¨|jƒ\}}|jd}|d}t|jj|ƒ}|jƒ}d}|dk r†|jƒ\} } || | |}ytjj|t ƒ}dj |ƒ}WnYnXd|||f} |rœ| Sd|| fS)NZ__dr†rCz [{:%Y-%m-%d %H:%M:%S}]z%d%s%sz%s = { %s })r‘rVr}rr"r…rrZ fromtimestampÚ _utc_timezoner*)rZabbrevrÚoffsetr„r‡ÚprinterÚsuffixÚtimerÂr~Zsecsrr#rrrrg1s$ z#StdChronoTimePointPrinter.to_stringN)F)r r rrrXr‘rgrrrrrˆsrˆc@s eZdZdZdd„Zdd„ZdS)ÚStdChronoZonedTimePrinterz Print a std::chrono::zoned_time.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrXIs z"StdChronoZonedTimePrinter.__init__cCs@|jdjƒd}|jd}t|jj|ƒ}|jdƒ}dj||ƒS)NZ_M_zoneÚ_M_nameZ_M_tpTz%std::chrono::zoned_time = {{ {} {} }})rVrtrˆrr"rgr*)rZzoner–r”rrrrgMs z#StdChronoZonedTimePrinter.to_stringN)r r rrrXrgrrrrr—Fsr—ZJanuaryZFebruaryZMarchZAprilZMayZJuneZJulyZAugustZ SeptemberZOctoberZNovemberZDecemberZSundayZMondayZTuesdayZ WednesdayZThursdayZFridayZSaturdayc@s eZdZdZdd„Zdd„ZdS)ÚStdChronoCalendarPrinterzDPrint a std::chrono::day, std::chrono::month, std::chrono::year etc.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX_s z!StdChronoCalendarPrinter.__init__c Csv|j}|j}d|kr$|dkr$|d}|jdƒr6|d}|dkrPdjt|dƒƒS|d kr||d ksl|ttƒkrtd|St|S|dkrŽdj|ƒS|d krÈ|d}|dks²|ttƒkrºd|Sdjt|ƒS|dkrèdj|dt|dƒƒS|dkrþdj|dƒS|dkrdj||dƒS|dkr,dj|ƒS|dkrFdj||dƒS|dkr`dj||dƒS|dkrvdj||ƒS|dkr’d j|||dƒS|dkr¬dj||d!ƒS|d"krÈd j|||dƒS|d#kräd j|||dƒS|jd$ƒrrd%}|d&dkr"d'jt|d(d)ƒt|d&ƒƒ}t|d*d+ƒ}t|dd+ƒ}t|d,d+ƒ}|d-rb|}d.j||||ƒSdS)/NÚmonthz std::chrono::year_month_day_lastZ_M_mzstd::chrono::yearZ_M_yzstd::chrono::dayz{}Z_M_dzstd::chrono::monthr)z%d is not a valid monthz{}yzstd::chrono::weekdayZ_M_wdrz%d is not a valid weekdayzstd::chrono::weekday_indexedz{}[{}]r.zstd::chrono::weekday_lastz{}[last]zstd::chrono::month_dayz{}/{}zstd::chrono::month_day_lastz{}/lastzstd::chrono::month_weekdayZ_M_wdizstd::chrono::month_weekday_lastZ_M_wdlzstd::chrono::year_monthzstd::chrono::year_month_dayz{}/{}/{}Z_M_mdlzstd::chrono::year_month_weekdayz$std::chrono::year_month_weekday_lastzstd::chrono::hh_mm_ssrCZfractional_widthz.{:0{}d}Z_M_ssZ_M_rrr†Ú_M_sZ _M_is_negz{:02}:{:02}:{:02}{})rVr]r<r*r¤rÚmonthsÚweekdays) rrWr#r"ÚyZwdZfractrƒr#rrrrgcsh z"StdChronoCalendarPrinter.to_stringN)r r rrrXrgrrrrr™\sr™c@s eZdZdZdd„Zdd„ZdS)ÚStdChronoTimeZonePrinterz4Print a chrono::time_zone or chrono::time_zone_link.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrXžs z!StdChronoTimeZonePrinter.__init__cCs6d|j|jdf}|jjdƒr2|d|jd7}|S)Nz%s = %sr˜Z_linkz -> %sZ _M_target)r]rVrb)rr!rrrrg¢sz"StdChronoTimeZonePrinter.to_stringN)r r rrrXrgrrrrrŸ›srŸc@s eZdZdZdd„Zdd„ZdS)ÚStdChronoLeapSecondPrinterzPrint a chrono::leap_second.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX¬s z#StdChronoLeapSecondPrinter.__init__cCs.|jdd}d|dk}d|jt|ƒ|fS)Nr›r†z+-rz %s %d (%c))rVr]Úabs)rZdaternrrrrg°sz$StdChronoLeapSecondPrinter.to_stringN)r r rrrXrgrrrrr ©sr c@s eZdZdZdd„Zdd„ZdS)ÚStdChronoTzdbPrinterzPrint a chrono::tzdb.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrX¹s zStdChronoTzdbPrinter.__init__cCsd|j|jdfS)Nz%s %sÚversion)r]rV)rrrrrg½szStdChronoTzdbPrinter.to_stringN)r r rrrXrgrrrrr¢¶sr¢c@s eZdZdZdd„Zdd„ZdS)ÚStdChronoTimeZoneRulePrinterzPrint a chrono::time_zone rule.cCst|ƒ|_||_dS)N)r;r]rV)rrDrWrrrrXÄs z%StdChronoTimeZoneRulePrinter.__init__c CsÜ|jd}|d}t|d}ddddddddœ}|d}d j||j|d ƒƒ}|dkrddj||ƒ}nVt|d }|dkr†dj||ƒ}n4|dkr”d} nd} |d}dj| d|| d||ƒ}dj|jd|jd|jd|ƒS)NÚonÚkindršÚstZndZrd)r)rrCééééZday_of_monthz{}{}Zthrz{} {}Zday_of_weekr)z last {} in {}rrØú<=rÈú>=z{} {} {} {} {}z.time_zone rule {} from {} to {} starting on {}r"ÚfromZto)rØr¬)rÈr)rVrœr*Úgetr) rr¥r¦ršÚsuffixesÚdayZordinal_dayr›ÚweekdayÚ directionrrrrgÈs* z&StdChronoTimeZoneRulePrinter.to_stringN)r r rrrXrgrrrrr¤Ásr¤c@s eZdZdZdd„Zdd„ZdS)ÚStdLocalePrinterzPrint a std::locale.cCs||_||_dS)N)rVr])rrDrWrrrrXæszStdLocalePrinter.__init__csx|jdd}d}|ddkr&d}nFtj|jdƒ}tj|jdƒ}|djƒ}|djƒ}dj||ƒ}||i}d } xN| |krÄ|| dkrÄ|| jƒ}|| jƒ}d j|||ƒ}|||<| d } qxWt|jƒƒ} t| ƒd krä|}nˆt| ƒdkrl| \}}t |jƒƒ} d‰| j |ƒd kr$|}|‰n| j |ƒd kr<|}|‰ˆdk rlt‡fdd „|jƒDƒƒ}dj|ˆƒ}dj||ƒS)Nr„Z_M_namesrCrÚ*z::_S_categoriesz::_S_categories_sizez{}={}r)z{};{}={}rc3s|]\}}|ˆkr|VqdS)Nr)r&r²rR)Úotherrrú sz-StdLocalePrinter.to_string..z with "{}={}"zstd::locale = "{}"{}) rVrrór]rær*r4Úvaluesrr‰rErÚitems)rrPÚmodr"ZcatsZncatrRr[Z cat_namesrZ uniq_namesZn1Zn2Z name_listr)r¶rrgêsD zStdLocalePrinter.to_stringN)r r rrrXrgrrrrr´ãsr´c@s eZdZdZdd„Zdd„ZdS)ÚStdIntegralConstantPrinterz*Print a std::true_type or std::false_type.cCs||_||_dS)N)rVr])rrDrWrrrrX sz#StdIntegralConstantPrinter.__init__cCsL|jjjdƒ}|jjjdƒ}|jtjkr4|r0dSdSt|jƒ}dj|||ƒS)Nrr)zstd::true_typezstd::false_typez {}<{}, {}>) rVrr4rŸrr r;r]r*)rr3rZrDrrrrg s z$StdIntegralConstantPrinter.to_stringN)r r rrrXrgrrrrr» sr»c@s eZdZdZdd„Zdd„ZdS)ÚStdTextEncodingPrinterzPrint a std::text_encoding.cCs||_||_dS)N)rVr])rrDrWrrrrX$ szStdTextEncodingPrinter.__init__cCs<|jdjƒ}|ddkr$|jdS|ddkr4dS|dS)NZ_M_repZ_M_idr)r˜rrq)rVrt)rZreprrrrg( s z StdTextEncodingPrinter.to_stringN)r r rrrXrgrrrrr¼! sr¼cs$eZdZ‡fdd„Zdd„Z‡ZS)Ú RxPrintercs$tt|ƒjƒ||_||_d|_dS)NT)rr½rXr"Ú _functionÚenabled)rr"r)r$rrrX3 szRxPrinter.__init__cCs:|js dS|jjtjkr,ttjdƒr,|jƒ}|j|j |ƒS)NÚreferenced_value) r¿rrŸrrärµÚValuerÀr¾r")rrZrrrÚinvoke9 szRxPrinter.invoke)r r rrXrÂr(rr)r$rr½2 sr½csHeZdZ‡fdd„Zdd„Zdd„Zdd„Zed d „ƒZdd„Z ‡Z S) ÚPrintercs6tt|ƒjƒ||_g|_i|_d|_tjdƒ|_ dS)NTz^([a-zA-Z0-9_:]+)(<.*>)?$) rrÃrXr"Ú_subprintersÚ_lookupr¿r>ÚcompileÚ_compiled_rx)rr")r$rrrXH szPrinter.__init__cCs<|jj|ƒstd|ƒ‚t||ƒ}|jj|ƒ||j|<dS)Nz0libstdc++ programming error: "%s" does not match)rÇr?r r½rÄrPrÅ)rr"rr”rrrÚaddP s zPrinter.addcCs>|j|||ƒd|kr:tjddt|ƒ}|j|||ƒdS)NÚ__cxx11z^(std|__gnu_cxx)::z\g<0>%s)rÈr>rHr-)rÚbaser"rZvbaserrrÚadd_version[ s zPrinter.add_versioncCs$|j|||ƒ|j|d||ƒdS)Nz__cxx1998::)rË)rrÊr"rrrrÚ add_containerc szPrinter.add_containercCs&|jtjkr|jƒ}|jƒjƒ}|jS)N)rŸrrärÐrårr)rrrrÚget_basic_typeg szPrinter.get_basic_typecCsr|j|jƒ}|sdS|jj|ƒ}|s(dS|jdƒ}|jjtjkrTttj dƒrT|j ƒ}||jkrn|j|j|ƒSdS)Nr)rÀ) rÍrrÇr?rrŸrrärµrÁrÀrÅrÂ)rrWrDr?ÚbasenamerrrÚ__call__r s zPrinter.__call__)r r rrXrÈrËrÌr°rÍrÏr(rr)r$rrÃG srÃ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 >' with 'std::vector'. cCs||_||_d|_dS)NT)r"Ú_defargsr¿)rr"ÚdefargsrrrrX˜ szTemplateTypePrinter.__init__c@s(eZdZdZdd„Zdd„Zdd„ZdS) zTemplateTypePrinter._recognizerz-The recognizer class for TemplateTypePrinter.cCs||_||_dS)N)r"rÑ)rr"rÒrrrrX sz(TemplateTypePrinter._recognizer.__init__c Csú|jdkrdS|jj|jƒs dSt|ƒ}g}d}x”tt|ƒƒD]„}||}|jj|ƒ}|dk rª|j|Ž}y|t j |ƒkr|dSWn$t jk r¢|j|krždSYnXd}q>|r²dS|j|j |ƒƒq>W|jd|jjdƒ…}t|ƒ}|ddj|ƒ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ú)rr<r"rTÚrangerrÑr¯r*rrr,rPÚ_recognize_subtyperárOr+) rrQrSZdisplayed_argsZrequire_defaultedrRrfZdefargrArrrÚ recognize¥ s2 z)TemplateTypePrinter._recognizer.recognizecCsÔ|jtjkr|j|jƒƒdS|jtjkrj|j|jƒƒ}t|jƒƒjdƒrR|dSd||j ƒddfS|jtj krˆ|j|jƒƒdSttdƒr°|jtjkr°|j|jƒƒdStj jtj jƒ|ƒ}|rÌ|St|ƒS)zxConvert a gdb.Type to a string by applying recognizers, or if that fails then simply converting to a string.rµz[]z%s[%d]r)ú&ÚTYPE_CODE_RVALUE_REFz&&)rŸrrzrÖrÐrÏr!rrbrÕrärµrÙrrr)rrQrNrrrrÖÖ s" z2TemplateTypePrinter._recognizer._recognize_subtypeN)r r rrrXr×rÖrrrrÚ_recognizer s1rÚcCs|j|j|jƒS)z1Return a recognizer object for this type printer.)rÚr"rÑ)rrrrÚinstantiateí szTemplateTypePrinter.instantiateN)r r rrrXÚobjectrÚrÛrrrrrÐ s PrÐcsžtd||ƒ}tjj||ƒtd||ƒ}tjj||ƒd|kršdt‰t‡fdd„|jƒDƒƒ}tˆ||ƒ}tjj||ƒtd||ƒ}tjj||ƒ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 >' } zstd::zstd::__debug::rÉc3s"|]\}}||jdˆƒfVqdS)zstd::N)r.)r&rRr„)rWrrr· sz0add_one_template_type_printer..N)rÐrrÚregister_type_printerr-Údictr¹)Úobjr"rÒr”r)rWrÚadd_one_template_type_printerò sràc@s2eZdZdZd dd„ZGdd„deƒZdd„ZdS) ÚFilteringTypePrintera› A type printer that uses typedef names for common template specializations. Args: template (str): The class template to recognize. name (str): The typedef-name that will be used instead. targ1 (str, optional): The first template argument. Defaults to None. Checks if a specialization of the class template 'template' is the same type as the typedef 'name', and prints it as 'name' instead. e.g. if an instantiation of std::basic_istream is the same type as std::istream then print it as std::istream. If targ1 is provided (not None), match only template specializations with this type as the first template argument, e.g. if template='basic_string' and targ1='char' then only match 'basic_string' and not 'basic_string'. This rejects non-matching specializations more quickly, without needing to do GDB type lookups. NcCs||_||_||_d|_dS)NT)Ú _templater"Ú_targ1r¿)rÚtemplater"Útarg1rrrrX- szFilteringTypePrinter.__init__c@s eZdZdZdd„Zdd„ZdS)z FilteringTypePrinter._recognizerz.The recognizer class for FilteringTypePrinter.cCs||_||_||_d|_dS)N)râr"rãÚ _type_obj)rrär"rårrrrX6 sz)FilteringTypePrinter._recognizer.__init__c Csü|jdkrdS|jdkrz|jdk rDdj|j|jƒ}|jj|ƒsVdSn|jj|jƒsVdSytj|jƒj ƒ|_WnYnX|jdkrˆdStj j|jƒ}tj j|ƒ}||kr´t|jƒS|jj dƒddkrø|jjjddƒ}|jjddƒ}||krøt|jƒSdS) z• If type_obj starts with self._template and is the same type as self.name then return self.name, otherwise None. Nz{}<{}z::r)Úbasic_stringz __cxx11::rCri)rrærãr*râr<rrr"rrrÍrOrer.)rrQr#Zt1Zt2Ús1Ús2rrrr×< s4 z*FilteringTypePrinter._recognizer.recognizeN)r r rrrXr×rrrrrÚ3 srÚcCs|j|j|j|jƒS)z1Return a recognizer object for this type printer.)rÚrâr"rã)rrrrrÛf sz FilteringTypePrinter.instantiate)N)r r rrrXrÜrÚrÛrrrrrá s 3rácCsXtd|d||ƒ}tjj||ƒd|krTdt}t|||||ƒ}tjj||ƒdS)Nzstd::rÉ)rárrrÝr-)rßrär"rår”rWrrrÚadd_one_type_printerk srêc CsdtsdSxxdgD]p}t|d|dd |dƒt|d|dd |dƒt|dd|dd |dƒt|d|dd|dƒqWx„djD]|}x*dkD]"}t|d||d||dƒq’WxJdlD]B}t|d||d||dƒt|d!||d||dƒq¾WqˆWxdmD]ˆ}x0dpD](}t||d"||dd#|dƒqWxNdqD]F}t||d(||d)ƒx&drD]}t||||||ƒqlWqJWqWt|d-d.ƒxdsD]}t|d9d:|ƒq¬Wt|d;d<ƒt|d;d=ƒt|d>d?ƒt|d>d@ƒt|dAdBƒt|dAdCƒt|dDdEƒt|dDdFƒt|dGdHƒdI}x0dyD](}t||d||dd|dƒqÚdequezstd::allocator<{0}>r‹r‰z __cxx11::listÚvectorrÌzstd::less<{0}>z)std::allocator>)rrCÚmultimapr4)r)rÚmultisetÚ unordered_mapzstd::hash<{0}>zstd::equal_to<{0}>)rrCéÚunordered_multimapÚ unordered_set)r)rrCÚunordered_multiset©rCrE©rÑr|©rërì©rírî©rïrð)rrrrr©rCrE©rÑr|)rr) rórérôrõrör÷rørùrú)rürýrþrÿ)rCrñ©rCrE©rÑr|)rr )r²r#rr)rrr) rrrrr r rrr rœ©rCrE©rÑr|©rërì©rírî©rïrð)r!r"r#r$r%)rrêrà)rßZchr@ÚabiZdurrWrrrÚregister_type_printerst s® "( * r'cCs8trtjj|tƒn|dkr t}|jjtƒt|ƒdS)z4Register libstdc++ pretty-printers with objfile Obj.N)Ú_use_gdb_pprZprintingZregister_pretty_printerÚlibstdcxx_printerZpretty_printersrPr')rßrrrÚregister_libstdcxx_printersã sr*cCsXtdƒatjddtƒtjddtƒtjddtƒtjddtƒtjddtƒtjddtƒtjddtƒtjdd tƒtjdd t ƒtjddt ƒtjddtƒtjdd tƒtjddtƒtjddt ƒtjddtƒtjddt ƒtjddtƒtjddtƒttjdƒr.tjddtƒtjddtƒtjdtƒtjdtƒtjdtƒtjdtƒtjdtƒtjdt ƒtjdt ƒtjdtƒtjddtƒtjdd tƒtjdd!tƒtjdd"tƒtjdd#tƒtjdd$tƒtjdd%tƒtjd&dtƒtjd&d tƒtjd&d!tƒtjd&d"tƒtjd&d#tƒtjd&d$tƒtjdd'tƒtjdd(tƒtjdd)tƒtjdd)tƒx2doD]*}tjdd-|tƒtjdd-|tƒq‚Wtjd.d/tƒtjd.d0tƒtjdd1tƒtjd2d3t ƒtjd4tƒtjd5tƒtjd6tƒtjd7tƒtjd8tƒtjd9d:t!ƒtjd9d;t"ƒtjd9dt$ƒtjd?d>t$ƒtjd@d>t%ƒtjdAd>t%ƒtjdd:t!ƒtjdd;t"ƒtjddrFrirrGrÜrrÌr Úziprr¤rÞZtimezoneZutcr’Ztzinforr(Zgdb.printingrTrZ gdb.typesrµrrZprinter_baser%r-r2r8r5rBr;rKrOrTrUr[rkrmrprqrurxryr†rˆrŠrrrr©rªr«r¬r±r¶r½r¾rÁrÃrÄrÍrÎrÓrßràrírîrðrörürr rrrrr)r-r0r5r7rBrJrLrQrlrsrurvr{r}rˆr—rœrr™rŸr r¢r¤r´r»r¼r½rÃr)rÐràrárêr'r*r;rrrrÚsö % (&"I U(*$/A" /%-^!,5I!{'$*/? ",Ce%T oTPKr1]äÔeæŽæŽ=python/libstdcxx/v6/__pycache__/xmethods.cpython-36.opt-1.pycnu„[µü¤3 À¡hqã@sœddlZddlZddlZdZdd„Zdd„ZdZdd „ZGd d„dejj ƒZ Gdd „d ejjƒZGdd„deƒZ Gdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„deƒZGdd„dejjƒZGdd„dejjƒZGdd„deƒZGd d!„d!eƒZGd"d#„d#eƒZGd$d%„d%eƒZGd&d'„d'eƒZGd(d)„d)eƒZGd*d+„d+ejjƒZGd,d-„d-ejjƒZGd.d/„d/eƒZGd0d1„d1eƒZGd2d3„d3ejjƒZ Gd4d5„d5ejjƒZ!Gd6d7„d7e!ƒZ"Gd8d9„d9e!ƒZ#Gd:d;„d;e!ƒZ$Gdd?„d?ejjƒZ&Gd@dA„dAejjƒZ'GdBdC„dCe'ƒZ(GdDdE„dEe'ƒZ)GdFdG„dGe'ƒZ*GdHdI„dIe'ƒZ+GdJdK„dKe'ƒZ,GdLdM„dMe'ƒZ-GdNdO„dOejjƒZ.GdPdQ„dQejjƒZ/GdRdS„dSe/ƒZ0GdTdU„dUe/ƒZ1GdVdW„dWejjƒZ2GdXdY„dYejjƒZ3GdZd[„d[e3ƒZ4Gd\d]„d]e3ƒZ5Gd^d_„d_ejjƒZ6Gd`da„daejjƒZ7Gdbdc„dce7ƒZ8Gddde„dee7ƒZ9Gdfdg„dgejjƒZ:Gdhdi„die:ƒZ;Gdjdk„dkejjƒZ$N)Ú isinstancerZTypeÚtagÚ_versioned_namespaceÚreÚmatch)ÚxZ template_namerrrÚis_specialization_of!src@seZdZdd„ZdS)ÚLibStdCxxXMethodcCstjjj||ƒ||_dS)N)rÚxmethodÚXMethodÚ__init__Úworker_class)ÚselfÚnamerrrrr.szLibStdCxxXMethod.__init__N)Ú__name__Ú __module__Ú__qualname__rrrrrr-src@seZdZdd„Zdd„ZdS)ÚArrayWorkerBasecCs||_||_dS)N)Ú _val_typeÚ_size)rÚval_typeÚsizerrrr6szArrayWorkerBase.__init__cCstjdƒ}|j|jjƒƒjƒS)Nz (void *) 0)rZparse_and_evalÚcastrÚpointerÚdereference)rZnullptrrrrÚ null_value:s zArrayWorkerBase.null_valueN)rrrrr"rrrrr5src@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) ÚArraySizeWorkercCstj|||ƒdS)N)rr)rrrrrrr@szArraySizeWorker.__init__cCsdS)Nr)rrrrÚ get_arg_typesCszArraySizeWorker.get_arg_typescCstƒS)N)r)rÚobjrrrÚget_result_typeFszArraySizeWorker.get_result_typecCs|jS)N)r)rr%rrrÚ__call__IszArraySizeWorker.__call__N)rrrrr$r&r'rrrrr#?sr#c@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) ÚArrayEmptyWorkercCstj|||ƒdS)N)rr)rrrrrrrNszArrayEmptyWorker.__init__cCsdS)Nr)rrrrr$QszArrayEmptyWorker.get_arg_typescCstƒS)N)r)rr%rrrr&Tsz ArrayEmptyWorker.get_result_typecCst|jƒdkS)Nr)Úintr)rr%rrrr'WszArrayEmptyWorker.__call__N)rrrrr$r&r'rrrrr(Msr(c@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) ÚArrayFrontWorkercCstj|||ƒdS)N)rr)rrrrrrr\szArrayFrontWorker.__init__cCsdS)Nr)rrrrr$_szArrayFrontWorker.get_arg_typescCs|jS)N)r)rr%rrrr&bsz ArrayFrontWorker.get_result_typecCs&t|jƒdkr|ddS|jƒSdS)NrÚ_M_elems)r)rr")rr%rrrr'eszArrayFrontWorker.__call__N)rrrrr$r&r'rrrrr*[sr*c@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) ÚArrayBackWorkercCstj|||ƒdS)N)rr)rrrrrrrmszArrayBackWorker.__init__cCsdS)Nr)rrrrr$pszArrayBackWorker.get_arg_typescCs|jS)N)r)rr%rrrr&sszArrayBackWorker.get_result_typecCs,t|jƒdkr |d|jdS|jƒSdS)Nrr+é)r)rr")rr%rrrr'vszArrayBackWorker.__call__N)rrrrr$r&r'rrrrr,lsr,c@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) Ú ArrayAtWorkercCstj|||ƒdS)N)rr)rrrrrrr~szArrayAtWorker.__init__cCstƒS)N)r)rrrrr$szArrayAtWorker.get_arg_typescCs|jS)N)r)rr%Úindexrrrr&„szArrayAtWorker.get_result_typecCs4t|ƒt|jƒkr(tdt|ƒ|jfƒ‚|d|S)Nz%Array index "%d" should not be >= %d.r+)r)rÚ IndexError)rr%r/rrrr'‡szArrayAtWorker.__call__N)rrrrr$r&r'rrrrr.}sr.c@s,eZdZdd„Zdd„Zdd„Zdd„Zd S) ÚArraySubscriptWorkercCstj|||ƒdS)N)rr)rrrrrrrszArraySubscriptWorker.__init__cCstƒS)N)r)rrrrr$’sz"ArraySubscriptWorker.get_arg_typescCs|jS)N)r)rr%r/rrrr&•sz$ArraySubscriptWorker.get_result_typecCs&t|jƒdkr|d|S|jƒSdS)Nrr+)r)rr")rr%r/rrrr'˜szArraySubscriptWorker.__call__N)rrrrr$r&r'rrrrr1Žsr1c@seZdZdd„Zdd„ZdS)ÚArrayMethodsMatchercsftjjjˆtdƒtdtƒtdtƒtdtƒtdt ƒtdt ƒtdtƒdœˆ_‡fd d „ˆjDƒˆ_ dS)NÚarrayrÚemptyÚfrontÚbackÚatz operator[])rr4r5r6r7z operator[]csg|]}ˆj|‘qSr)Ú_method_dict)Ú.0Úm)rrrú «sz0ArrayMethodsMatcher.__init__..)rrÚXMethodMatcherrÚmatcher_name_prefixrr#r(r*r,r.r1r8Úmethods)rr)rrr s zArrayMethodsMatcher.__init__c Cs^t|dƒsdS|jj|ƒ}|dks*|jr.dSy|jdƒ}|jdƒ}Wn dS|j||ƒS)Nr3rr-)rr8ÚgetÚenabledÚtemplate_argumentr)rÚ class_typeÚmethod_nameÚmethodZ value_typerrrrr s zArrayMethodsMatcher.matchN)rrrrr rrrrr2Ÿs r2c@s$eZdZdd„Zdd„Zdd„ZdS)ÚDequeWorkerBasecCs||_d|jpd|_dS)Nir-)rÚsizeofÚ_bufsize)rrrrrr¿szDequeWorkerBase.__init__cCsf|dd}|dd}|d|dkr,dS|j|d|dd|d|d|d |dS) NÚ_M_implÚ_M_startÚ _M_finishÚ_M_currÚ_M_noder-Ú_M_firstÚ_M_last)rG)rr%ÚstartÚfinishrrrrÃs zDequeWorkerBase.sizecCs`|dd}|d|d}||kr0|d|S||}|ddt|ƒ|j}|||jS)NrHrIrNrKrLr-)r)rG)rr%ÚidxrOZfirst_node_sizeZ index_noderrrr/ÍszDequeWorkerBase.indexN)rrrrrr/rrrrrE¾s rEc@s$eZdZdd„Zdd„Zdd„ZdS)ÚDequeEmptyWorkercCsdS)Nr)rrrrr$ØszDequeEmptyWorker.get_arg_typescCstƒS)N)r)rr%rrrr&Ûsz DequeEmptyWorker.get_result_typecCs |ddd|dddkS)NrHrIrKrJr)rr%rrrr'ÞszDequeEmptyWorker.__call__N)rrrr$r&r'rrrrrR×srRc@s$eZdZdd„Zdd„Zdd„ZdS)ÚDequeSizeWorkercCsdS)Nr)rrrrr$äszDequeSizeWorker.get_arg_typescCstƒS)N)r)rr%rrrr&çszDequeSizeWorker.get_result_typecCs |j|ƒS)N)r)rr%rrrr'êszDequeSizeWorker.__call__N)rrrr$r&r'rrrrrSãsrSc@s$eZdZdd„Zdd„Zdd„ZdS)ÚDequeFrontWorkercCsdS)Nr)rrrrr$ïszDequeFrontWorker.get_arg_typescCs|jS)N)r)rr%rrrr&òsz DequeFrontWorker.get_result_typecCs|ddddS)NrHrIrKrr)rr%rrrr'õszDequeFrontWorker.__call__N)rrrr$r&r'rrrrrTîsrTc@s$eZdZdd„Zdd„Zdd„ZdS)ÚDequeBackWorkercCsdS)Nr)rrrrr$úszDequeBackWorker.get_arg_typescCs|jS)N)r)rr%rrrr&ýszDequeBackWorker.get_result_typecCs^|ddd|dddkrF|dddd}|d|jdS|ddddSdS) NrHrJrKrMrLr-réÿÿÿÿ)rG)rr%Ú prev_noderrrr's zDequeBackWorker.__call__N)rrrr$r&r'rrrrrUùsrUc@s$eZdZdd„Zdd„Zdd„ZdS)ÚDequeSubscriptWorkercCstƒS)N)r)rrrrr$ sz"DequeSubscriptWorker.get_arg_typescCs|jS)N)r)rr%Ú subscriptrrrr& sz$DequeSubscriptWorker.get_result_typecCs|j||ƒS)N)r/)rr%rYrrrr'szDequeSubscriptWorker.__call__N)rrrr$r&r'rrrrrX srXc@s$eZdZdd„Zdd„Zdd„ZdS)Ú DequeAtWorkercCstƒS)N)r)rrrrr$szDequeAtWorker.get_arg_typescCs|jS)N)r)rr%r/rrrr&szDequeAtWorker.get_result_typecCs@t|j|ƒƒ}t|ƒ|kr0tdt|ƒ|fƒ‚n|j||ƒSdS)Nz%Deque index "%d" should not be >= %d.)r)rr0r/)rr%r/Z deque_sizerrrr's zDequeAtWorker.__call__N)rrrr$r&r'rrrrrZsrZc@seZdZdd„Zdd„ZdS)ÚDequeMethodsMatchercsftjjjˆtdƒtdtƒtdtƒtdtƒtdt ƒtdt ƒtdtƒdœˆ_‡fd d „ˆjDƒˆ_ dS)NÚdequer4rr5r6z operator[]r7)r4rr5r6z operator[]r7csg|]}ˆj|‘qSr)r8)r9r:)rrrr;0sz0DequeMethodsMatcher.__init__..)rrr<rr=rrRrSrTrUrXrZr8r>)rr)rrr%s zDequeMethodsMatcher.__init__cCs>t|dƒsdS|jj|ƒ}|dks*|jr.dS|j|jdƒƒS)Nr\r)rr8r?r@rrA)rrBrCrDrrrr 2s zDequeMethodsMatcher.matchN)rrrrr rrrrr[$s r[c@seZdZdd„Zdd„ZdS)ÚForwardListWorkerBasecCs||_||_dS)N)rÚ _node_type)rrÚ node_typerrrr>szForwardListWorkerBase.__init__cCsdS)Nr)rrrrr$Bsz#ForwardListWorkerBase.get_arg_typesN)rrrrr$rrrrr]=sr]c@seZdZdd„Zdd„ZdS)ÚForwardListEmptyWorkercCstƒS)N)r)rr%rrrr&Gsz&ForwardListEmptyWorker.get_result_typecCs|ddddkS)NrHÚ_M_headÚ_M_nextrr)rr%rrrr'JszForwardListEmptyWorker.__call__N)rrrr&r'rrrrr`Fsr`c@seZdZdd„Zdd„ZdS)ÚForwardListFrontWorkercCs|jS)N)r)rr%rrrr&Osz&ForwardListFrontWorker.get_result_typecCs:|dddj|jƒ}|ddj}|j|jjƒƒjƒS)NrHrarbÚ _M_storage)rr^Úaddressrr r!)rr%ÚnodeZval_addressrrrr'RszForwardListFrontWorker.__call__N)rrrr&r'rrrrrcNsrcc@seZdZdd„Zdd„ZdS)ÚForwardListMethodsMatchercsJtd}tjjjˆ|ƒtdtƒtdtƒdœˆ_‡fdd„ˆjDƒˆ_ dS)NÚforward_listr4r5)r4r5csg|]}ˆj|‘qSr)r8)r9r:)rrrr;`sz6ForwardListMethodsMatcher.__init__..) r=rrr<rrr`rcr8r>)rZmatcher_namer)rrrYs z"ForwardListMethodsMatcher.__init__cCsZt|dƒsdS|jj|ƒ}|dks*|jr.dS|jdƒ}tjt|ƒdƒjƒ}|j ||ƒS)Nrhrz::_Node) rr8r?r@rArrÚstrr r)rrBrCrDrr_rrrr bs zForwardListMethodsMatcher.matchN)rrrrr rrrrrgXs rgc@s$eZdZdd„Zdd„Zdd„ZdS)ÚListWorkerBasecCs||_||_dS)N)rr^)rrr_rrrrpszListWorkerBase.__init__cCsdS)Nr)rrrrr$tszListWorkerBase.get_arg_typescCsB|jƒ}|jjƒdjdkr$|dS|dj}|j|jjƒƒjƒS)Nr-Z_M_datard)r!ÚtypeÚfieldsrrerrr )rrfZaddrrrrÚget_value_from_nodews z"ListWorkerBase.get_value_from_nodeN)rrrrr$rmrrrrrjosrjc@seZdZdd„Zdd„ZdS)ÚListEmptyWorkercCstƒS)N)r)rr%rrrr&‚szListEmptyWorker.get_result_typecCs&|dd}|d|jkrdSdSdS)NrHrLrbTF)re)rr%Z base_noderrrr'…szListEmptyWorker.__call__N)rrrr&r'rrrrrnsrnc@seZdZdd„Zdd„ZdS)ÚListSizeWorkercCstƒS)N)r)rr%rrrr&ŽszListSizeWorker.get_result_typecCsD|ddd}|ddj}d}x||kr>|d}|d7}q$W|S)NrHrLrbrr-)re)rr%Z begin_nodeZend_noderrrrr'‘s zListSizeWorker.__call__N)rrrr&r'rrrrrosroc@seZdZdd„Zdd„ZdS)ÚListFrontWorkercCs|jS)N)r)rr%rrrr&œszListFrontWorker.get_result_typecCs"|dddj|jƒ}|j|ƒS)NrHrLrb)rr^rm)rr%rfrrrr'ŸszListFrontWorker.__call__N)rrrr&r'rrrrrp›srpc@seZdZdd„Zdd„ZdS)ÚListBackWorkercCs|jS)N)r)rr%rrrr&¥szListBackWorker.get_result_typecCs"|dddj|jƒ}|j|ƒS)NrHrLZ_M_prev)rr^rm)rr%rWrrrr'¨szListBackWorker.__call__N)rrrr&r'rrrrrq¤srqc@seZdZdd„Zdd„ZdS)ÚListMethodsMatchercsVtjjjˆtdƒtdtƒtdtƒtdtƒtdt ƒdœˆ_ ‡fdd„ˆj Dƒˆ_dS) NÚlistr4rr5r6)r4rr5r6csg|]}ˆj|‘qSr)r8)r9r:)rrrr;·sz/ListMethodsMatcher.__init__..)rrr<rr=rrnrorprqr8r>)rr)rrr®s zListMethodsMatcher.__init__cCsZt|dƒsdS|jj|ƒ}|dks*|jr.dS|jdƒ}tjt|ƒdƒjƒ}|j ||ƒS)Nz(__cxx11::)?listrz::_Node) rr8r?r@rArrrir r)rrBrCrDrr_rrrr ¹s zListMethodsMatcher.matchN)rrrrr rrrrrrsrrc@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorWorkerBasecCs ||_dS)N)r)rrrrrrÇszVectorWorkerBase.__init__cCsz|jjtjkr^|ddd}|ddd}|ddd}|jƒjjd}||||S|dd|ddSdS)NrHrIÚ_M_prJZ _M_offseté)rÚcoderÚTYPE_CODE_BOOLr!rkrF)rr%rOrPZ finish_offsetÚbit_sizerrrrÊszVectorWorkerBase.sizecCsj|jjtjkrV|ddd}|jƒjjd}|||}||}|jƒd|>@dkS|dd|SdS)NrHrIrurvr-r)rrwrrxr!rkrF)rr%r/rOryZvalpÚoffsetrrrr?ÔszVectorWorkerBase.getN)rrrrrr?rrrrrtÆs rtc@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorEmptyWorkercCsdS)Nr)rrrrr$àszVectorEmptyWorker.get_arg_typescCstƒS)N)r)rr%rrrr&ãsz!VectorEmptyWorker.get_result_typecCst|j|ƒƒdkS)Nr)r)r)rr%rrrr'æszVectorEmptyWorker.__call__N)rrrr$r&r'rrrrr{ßsr{c@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorSizeWorkercCsdS)Nr)rrrrr$ëszVectorSizeWorker.get_arg_typescCstƒS)N)r)rr%rrrr&îsz VectorSizeWorker.get_result_typecCs |j|ƒS)N)r)rr%rrrr'ñszVectorSizeWorker.__call__N)rrrr$r&r'rrrrr|êsr|c@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorFrontWorkercCsdS)Nr)rrrrr$öszVectorFrontWorker.get_arg_typescCs|jS)N)r)rr%rrrr&ùsz!VectorFrontWorker.get_result_typecCs|j|dƒS)Nr)r?)rr%rrrr'üszVectorFrontWorker.__call__N)rrrr$r&r'rrrrr}õsr}c@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorBackWorkercCsdS)Nr)rrrrr$szVectorBackWorker.get_arg_typescCs|jS)N)r)rr%rrrr&sz VectorBackWorker.get_result_typecCs|j|t|j|ƒƒdƒS)Nr-)r?r)r)rr%rrrr'szVectorBackWorker.__call__N)rrrr$r&r'rrrrr~sr~c@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorAtWorkercCstƒS)N)r)rrrrr$szVectorAtWorker.get_arg_typescCs|jS)N)r)rr%r/rrrr&szVectorAtWorker.get_result_typecCs>t|j|ƒƒ}t|ƒ|kr.tdt|ƒ|fƒ‚|j|t|ƒƒS)Nz&Vector index "%d" should not be >= %d.)r)rr0r?)rr%r/rrrrr's zVectorAtWorker.__call__N)rrrr$r&r'rrrrrsrc@s$eZdZdd„Zdd„Zdd„ZdS)ÚVectorSubscriptWorkercCstƒS)N)r)rrrrr$sz#VectorSubscriptWorker.get_arg_typescCs|jS)N)r)rr%rYrrrr&sz%VectorSubscriptWorker.get_result_typecCs|j|t|ƒƒS)N)r?r))rr%rYrrrr'!szVectorSubscriptWorker.__call__N)rrrr$r&r'rrrrr€sr€c@seZdZdd„Zdd„ZdS)ÚVectorMethodsMatchercsftjjjˆtdƒtdtƒtdtƒtdtƒtdt ƒtdt ƒtdtƒdœˆ_‡fd d „ˆjDƒˆ_ dS)NÚvectorrr4r5r6r7z operator[])rr4r5r6r7z operator[]csg|]}ˆj|‘qSr)r8)r9r:)rrrr;2sz1VectorMethodsMatcher.__init__..)rrr<rr=rr|r{r}r~rr€r8r>)rr)rrr&s zVectorMethodsMatcher.__init__cCs>t|dƒsdS|jj|ƒ}|dks*|jr.dS|j|jdƒƒS)Nr‚r)rr8r?r@rrA)rrBrCrDrrrr 4s zVectorMethodsMatcher.matchN)rrrrr rrrrr%src@s$eZdZdd„Zdd„Zdd„ZdS)ÚAssociativeContainerWorkerBasecCs ||_dS)N)Ú _unordered)rÚ unorderedrrrr@sz'AssociativeContainerWorkerBase.__init__cCs&|jr|ddS|dddSdS)NZ_M_hZ_M_element_countÚ_M_trHZ _M_node_count)r„)rr%rrrÚ node_countCsz)AssociativeContainerWorkerBase.node_countcCsdS)Nr)rrrrr$Isz,AssociativeContainerWorkerBase.get_arg_typesN)rrrrr‡r$rrrrrƒ?srƒc@seZdZdd„Zdd„ZdS)ÚAssociativeContainerEmptyWorkercCstƒS)N)r)rr%rrrr&Nsz/AssociativeContainerEmptyWorker.get_result_typecCst|j|ƒƒdkS)Nr)r)r‡)rr%rrrr'Qsz(AssociativeContainerEmptyWorker.__call__N)rrrr&r'rrrrrˆMsrˆc@seZdZdd„Zdd„ZdS)ÚAssociativeContainerSizeWorkercCstƒS)N)r)rr%rrrr&Vsz.AssociativeContainerSizeWorker.get_result_typecCs |j|ƒS)N)r‡)rr%rrrr'Ysz'AssociativeContainerSizeWorker.__call__N)rrrr&r'rrrrr‰Usr‰c@seZdZdd„Zdd„ZdS)Ú"AssociativeContainerMethodsMatchercsLtjjjˆt|ƒ|ˆ_tdtƒtdtƒdœˆ_ ‡fdd„ˆj Dƒˆ_ dS)Nrr4)rr4csg|]}ˆj|‘qSr)r8)r9r:)rrrr;gsz?AssociativeContainerMethodsMatcher.__init__..)rrr<rr=Ú_namerr‰rˆr8r>)rrr)rrr^s z+AssociativeContainerMethodsMatcher.__init__cCsDt||jƒsdS|jj|ƒ}|dks,|jr0dSd|jk}|j|ƒS)Nr…)rr‹r8r?r@r)rrBrCrDr…rrrr is z(AssociativeContainerMethodsMatcher.matchN)rrrrr rrrrrŠ]srŠc@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d„ZdS) ÚUniquePtrGetWorkerzS Implement std::unique_ptr::get() and std::unique_ptr::operator->(). cCs*|jtjk|_|jr |jƒ|_n||_dS)N)rwrÚTYPE_CODE_ARRAYÚ _is_arrayÚtargetÚ _elem_type)rÚ elem_typerrrrzszUniquePtrGetWorker.__init__cCsdS)Nr)rrrrr$sz UniquePtrGetWorker.get_arg_typescCs |jjƒS)N)rr )rr%rrrr&„sz"UniquePtrGetWorker.get_result_typecCs|dkp|jS)Nr?)rŽ)rrCrrrÚ _supports‡szUniquePtrGetWorker._supportscCs¢|jƒjjƒdjj}t|dƒr.|dd}nt|dƒrB|d}ndS|jjƒdj}|jƒdj}|jƒd}|jdkrˆ|j|ƒdS|jrš|j|jƒSdSdS)Nrz__uniq_ptr_(data|impl)r†Útupler-Z_M_head_impl)r!rkrlr rrrZ is_base_class)rr%Z impl_typeZtuple_memberZtuple_impl_typeZtuple_head_typeZ head_fieldrrrr'‹s zUniquePtrGetWorker.__call__N) rrrÚ__doc__rr$r&r’r'rrrrrŒusrŒc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)ÚUniquePtrDerefWorkerz*Implement std::unique_ptr::operator*().cCstj||ƒdS)N)rŒr)rr‘rrrr¢szUniquePtrDerefWorker.__init__cCs|jS)N)r)rr%rrrr&¥sz$UniquePtrDerefWorker.get_result_typecCs|jS)N)rŽ)rrCrrrr’¨szUniquePtrDerefWorker._supportscCstj||ƒjƒS)N)rŒr'r!)rr%rrrr'¬szUniquePtrDerefWorker.__call__N)rrrr”rr&r’r'rrrrr•Ÿs r•c@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d„ZdS) ÚUniquePtrSubscriptWorkerz1Implement std::unique_ptr::operator[](size_t).cCstj||ƒdS)N)rŒr)rr‘rrrr³sz!UniquePtrSubscriptWorker.__init__cCstƒS)N)r)rrrrr$¶sz&UniquePtrSubscriptWorker.get_arg_typescCs|jS)N)r)rr%r/rrrr&¹sz(UniquePtrSubscriptWorker.get_result_typecCs|jS)N)rŽ)rrCrrrr’¼sz"UniquePtrSubscriptWorker._supportscCstj||ƒ|S)N)rŒr')rr%r/rrrr'Àsz!UniquePtrSubscriptWorker.__call__N) rrrr”rr$r&r’r'rrrrr–°sr–c@seZdZdd„Zdd„ZdS)ÚUniquePtrMethodsMatchercsVtjjjˆtdƒtdtƒtdtƒtdtƒtdtƒdœˆ_ ‡fdd„ˆj Dƒˆ_ dS) NÚ unique_ptrr?z operator->z operator*z operator[])r?z operator->z operator*z operator[]csg|]}ˆj|‘qSr)r8)r9r:)rrrr;Îsz4UniquePtrMethodsMatcher.__init__..)rrr<rr=rrŒr•r–r8r>)rr)rrrÅs z UniquePtrMethodsMatcher.__init__cCsPt|dƒsdS|jj|ƒ}|dks*|jr.dS|j|jdƒƒ}|j|ƒrL|SdS)Nr˜r)rr8r?r@rrAr’)rrBrCrDÚworkerrrrr Ðs zUniquePtrMethodsMatcher.matchN)rrrrr rrrrr—Äsr—c@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d„ZdS) ÚSharedPtrGetWorkerzT Implements std::shared_ptr::get() and std::shared_ptr::operator->(). cCs*|jtjk|_|jr |jƒ|_n||_dS)N)rwrrrŽrr)rr‘rrrrãszSharedPtrGetWorker.__init__cCsdS)Nr)rrrrr$êsz SharedPtrGetWorker.get_arg_typescCs |jjƒS)N)rr )rr%rrrr&ísz"SharedPtrGetWorker.get_result_typecCs|dkp|jS)Nr?)rŽ)rrCrrrr’ðszSharedPtrGetWorker._supportscCs|dS)NZ_M_ptrr)rr%rrrr'ôszSharedPtrGetWorker.__call__N) rrrr”rr$r&r’r'rrrrršÞsršc@s0eZdZdZdd„Zdd„Zdd„Zdd „Zd S)ÚSharedPtrDerefWorkerz*Implement std::shared_ptr::operator*().cCstj||ƒdS)N)ršr)rr‘rrrrûszSharedPtrDerefWorker.__init__cCs|jS)N)r)rr%rrrr&þsz$SharedPtrDerefWorker.get_result_typecCs|jS)N)rŽ)rrCrrrr’szSharedPtrDerefWorker._supportscCstj||ƒjƒS)N)ršr'r!)rr%rrrr'szSharedPtrDerefWorker.__call__N)rrrr”rr&r’r'rrrrr›øs r›c@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d„ZdS) ÚSharedPtrSubscriptWorkerz1Implement std::shared_ptr::operator[](size_t).cCstj||ƒdS)N)ršr)rr‘rrrrsz!SharedPtrSubscriptWorker.__init__cCstƒS)N)r)rrrrr$sz&SharedPtrSubscriptWorker.get_arg_typescCs|jS)N)r)rr%r/rrrr&sz(SharedPtrSubscriptWorker.get_result_typecCs|jS)N)rŽ)rrCrrrr’sz"SharedPtrSubscriptWorker._supportscCsZtjdt|jƒƒ}|rJ|t|jdƒƒkrJtd|jt|ƒt|jdƒƒfƒ‚tj||ƒ|S)Nz.*\[(\d+)]$r-z.shared_ptr<%s> index "%d" should not be >= %d.) rr rirr)Úgroupr0ršr')rr%r/r:rrrr's z!SharedPtrSubscriptWorker.__call__N) rrrr”rr$r&r’r'rrrrrœ srœc@s8eZdZdZdd„Zdd„Zdd„Zdd „Zd d„ZdS) ÚSharedPtrUseCountWorkerz*Implement std::shared_ptr::use_count().cCsdS)Nr)rr‘rrrr%sz SharedPtrUseCountWorker.__init__cCsdS)Nr)rrrrr$(sz%SharedPtrUseCountWorker.get_arg_typescCs tjdƒS)NZlong)rr)rr%rrrr&+sz'SharedPtrUseCountWorker.get_result_typecCsdS)NTr)rrCrrrr’.sz!SharedPtrUseCountWorker._supportscCs|dd}|r|dSdS)NZ_M_refcountZ_M_piZ_M_use_countrr)rr%Z refcountsrrrr'1sz SharedPtrUseCountWorker.__call__N) rrrr”rr$r&r’r'rrrrrž"sržc@s(eZdZdZdd„Zdd„Zdd„ZdS) ÚSharedPtrUniqueWorkerz'Implement std::shared_ptr::unique().cCstj||ƒdS)N)ržr)rr‘rrrr9szSharedPtrUniqueWorker.__init__cCs tjdƒS)Nr)rr)rr%rrrr&<sz%SharedPtrUniqueWorker.get_result_typecCstj||ƒdkS)Nr-)ržr')rr%rrrr'?szSharedPtrUniqueWorker.__call__N)rrrr”rr&r'rrrrrŸ6srŸc@seZdZdd„Zdd„ZdS)ÚSharedPtrMethodsMatchercsftjjjˆtdƒtdtƒtdtƒtdtƒtdtƒtdt ƒtdt ƒdœˆ_‡fd d „ˆjDƒˆ_dS)NÚ shared_ptrr?z operator->z operator*z operator[]Ú use_countÚunique)r?z operator->z operator*z operator[]r¢r£csg|]}ˆj|‘qSr)r8)r9r:)rrrr;Osz4SharedPtrMethodsMatcher.__init__..) rrr<rr=rršr›rœržrŸr8r>)rr)rrrDs z SharedPtrMethodsMatcher.__init__cCsPt|dƒsdS|jj|ƒ}|dks*|jr.dS|j|jdƒƒ}|j|ƒrL|SdS)Nr¡r)rr8r?r@rrAr’)rrBrCrDr™rrrr Qs zSharedPtrMethodsMatcher.matchN)rrrrr rrrrr Cs r cCstjj|tƒƒtjj|tƒƒtjj|tƒƒtjj|tƒƒtjj|tƒƒtjj|tdƒƒtjj|tdƒƒtjj|tdƒƒtjj|tdƒƒtjj|tdƒƒtjj|tdƒƒtjj|tdƒƒtjj|tdƒƒtjj|t ƒƒtjj|t ƒƒdS) NÚsetÚmapZmultisetZmultimapZ unordered_setZ unordered_mapZunordered_multisetZunordered_multimap)rrZregister_xmethod_matcherr2rgr[rrrrŠr—r )ZlocusrrrÚregister_libstdcxx_xmethods]s.r¦)>rZgdb.xmethodrr=rrrrrrrZ XMethodWorkerrr#r(r*r,r.r1r<r2rErRrSrTrUrXrZr[r]r`rcrgrjrnrorprqrrrtr{r|r}r~rr€rrƒrˆr‰rŠrŒr•r–r—ršr›rœržrŸr r¦rrrrÚsr * PKr1] ÇBö667python/libstdcxx/v6/__pycache__/__init__.cpython-36.pycnu„[µü¤3 À¡h}ã@sdd„Zdd„ZdS)cCs&yddl}dStk r dSXdS)NéTF)Zgdb.xmethodÚImportError)Zgdb©rú0/usr/share/gcc-8/python/libstdcxx/v6/__init__.pyÚgdb_has_xmethodss rcCs2ddlm}||ƒtƒr.ddlm}||ƒdS)Né)Úregister_libstdcxx_printers)Úregister_libstdcxx_xmethods)ZprintersrrZxmethodsr)Úobjrrrrrrs rN)rrrrrrÚsPKr1]£ö…²qqpython/libstdcxx/v6/xmethods.pynu„[µü¤# Xmethods for libstdc++. # Copyright (C) 2014-2025 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import gdb import gdb.xmethod import re matcher_name_prefix = 'libstdc++::' def get_bool_type(): return gdb.lookup_type('bool') def get_std_size_type(): return gdb.lookup_type('std::size_t') _versioned_namespace = '__8::' def is_specialization_of(x, template_name): """ Test whether a type is a specialization of the named class template. The type can be specified as a string or a gdb.Type object. The template should be the name of a class template as a string, without any 'std' qualification. """ if isinstance(x, gdb.Type): x = x.tag template_name = '(%s)?%s' % (_versioned_namespace, template_name) return re.match(r'^std::(__\d::)?%s<.*>$' % template_name, x) is not None class LibStdCxxXMethod(gdb.xmethod.XMethod): def __init__(self, name, worker_class): gdb.xmethod.XMethod.__init__(self, name) self.worker_class = worker_class # Xmethods for std::array class ArrayWorkerBase(gdb.xmethod.XMethodWorker): def __init__(self, val_type, size): self._val_type = val_type self._size = size def null_value(self): nullptr = gdb.parse_and_eval('(void *) 0') return nullptr.cast(self._val_type.pointer()).dereference() class ArraySizeWorker(ArrayWorkerBase): def __init__(self, val_type, size): ArrayWorkerBase.__init__(self, val_type, size) def get_arg_types(self): return None def get_result_type(self, obj): return get_std_size_type() def __call__(self, obj): return self._size class ArrayEmptyWorker(ArrayWorkerBase): def __init__(self, val_type, size): ArrayWorkerBase.__init__(self, val_type, size) def get_arg_types(self): return None def get_result_type(self, obj): return get_bool_type() def __call__(self, obj): return (int(self._size) == 0) class ArrayFrontWorker(ArrayWorkerBase): def __init__(self, val_type, size): ArrayWorkerBase.__init__(self, val_type, size) def get_arg_types(self): return None def get_result_type(self, obj): return self._val_type def __call__(self, obj): if int(self._size) > 0: return obj['_M_elems'][0] else: return self.null_value() class ArrayBackWorker(ArrayWorkerBase): def __init__(self, val_type, size): ArrayWorkerBase.__init__(self, val_type, size) def get_arg_types(self): return None def get_result_type(self, obj): return self._val_type def __call__(self, obj): if int(self._size) > 0: return obj['_M_elems'][self._size - 1] else: return self.null_value() class ArrayAtWorker(ArrayWorkerBase): def __init__(self, val_type, size): ArrayWorkerBase.__init__(self, val_type, size) def get_arg_types(self): return get_std_size_type() def get_result_type(self, obj, index): return self._val_type def __call__(self, obj, index): if int(index) >= int(self._size): raise IndexError('Array index "%d" should not be >= %d.' % ((int(index), self._size))) return obj['_M_elems'][index] class ArraySubscriptWorker(ArrayWorkerBase): def __init__(self, val_type, size): ArrayWorkerBase.__init__(self, val_type, size) def get_arg_types(self): return get_std_size_type() def get_result_type(self, obj, index): return self._val_type def __call__(self, obj, index): if int(self._size) > 0: return obj['_M_elems'][index] else: return self.null_value() class ArrayMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): gdb.xmethod.XMethodMatcher.__init__(self, matcher_name_prefix + 'array') self._method_dict = { 'size': LibStdCxxXMethod('size', ArraySizeWorker), 'empty': LibStdCxxXMethod('empty', ArrayEmptyWorker), 'front': LibStdCxxXMethod('front', ArrayFrontWorker), 'back': LibStdCxxXMethod('back', ArrayBackWorker), 'at': LibStdCxxXMethod('at', ArrayAtWorker), 'operator[]': LibStdCxxXMethod('operator[]', ArraySubscriptWorker), } self.methods = [self._method_dict[m] for m in self._method_dict] def match(self, class_type, method_name): if not is_specialization_of(class_type, 'array'): return None method = self._method_dict.get(method_name) if method is None or not method.enabled: return None try: value_type = class_type.template_argument(0) size = class_type.template_argument(1) except: return None return method.worker_class(value_type, size) # Xmethods for std::deque class DequeWorkerBase(gdb.xmethod.XMethodWorker): def __init__(self, val_type): self._val_type = val_type self._bufsize = 512 // val_type.sizeof or 1 def size(self, obj): start = obj['_M_impl']['_M_start'] finish = obj['_M_impl']['_M_finish'] if start['_M_cur'] == finish['_M_cur']: return 0 return (self._bufsize * (finish['_M_node'] - start['_M_node'] - 1) + (finish['_M_cur'] - finish['_M_first']) + (start['_M_last'] - start['_M_cur'])) def index(self, obj, idx): start = obj['_M_impl']['_M_start'] first_node_size = start['_M_last'] - start['_M_cur'] if idx < first_node_size: return start['_M_cur'][idx] idx = idx - first_node_size index_node = start['_M_node'][1 + int(idx) // self._bufsize] return index_node[idx % self._bufsize] class DequeEmptyWorker(DequeWorkerBase): def get_arg_types(self): return None def get_result_type(self, obj): return get_bool_type() def __call__(self, obj): return (obj['_M_impl']['_M_start']['_M_cur'] == obj['_M_impl']['_M_finish']['_M_cur']) class DequeSizeWorker(DequeWorkerBase): def get_arg_types(self): return None def get_result_type(self, obj): return get_std_size_type() def __call__(self, obj): return self.size(obj) class DequeFrontWorker(DequeWorkerBase): def get_arg_types(self): return None def get_result_type(self, obj): return self._val_type def __call__(self, obj): return obj['_M_impl']['_M_start']['_M_cur'][0] class DequeBackWorker(DequeWorkerBase): def get_arg_types(self): return None def get_result_type(self, obj): return self._val_type def __call__(self, obj): if (obj['_M_impl']['_M_finish']['_M_cur'] == obj['_M_impl']['_M_finish']['_M_first']): prev_node = obj['_M_impl']['_M_finish']['_M_node'] - 1 return prev_node[0][self._bufsize - 1] else: return obj['_M_impl']['_M_finish']['_M_cur'][-1] class DequeSubscriptWorker(DequeWorkerBase): def get_arg_types(self): return get_std_size_type() def get_result_type(self, obj, subscript): return self._val_type def __call__(self, obj, subscript): return self.index(obj, subscript) class DequeAtWorker(DequeWorkerBase): def get_arg_types(self): return get_std_size_type() def get_result_type(self, obj, index): return self._val_type def __call__(self, obj, index): deque_size = int(self.size(obj)) if int(index) >= deque_size: raise IndexError('Deque index "%d" should not be >= %d.' % (int(index), deque_size)) else: return self.index(obj, index) class DequeMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): gdb.xmethod.XMethodMatcher.__init__(self, matcher_name_prefix + 'deque') self._method_dict = { 'empty': LibStdCxxXMethod('empty', DequeEmptyWorker), 'size': LibStdCxxXMethod('size', DequeSizeWorker), 'front': LibStdCxxXMethod('front', DequeFrontWorker), 'back': LibStdCxxXMethod('back', DequeBackWorker), 'operator[]': LibStdCxxXMethod('operator[]', DequeSubscriptWorker), 'at': LibStdCxxXMethod('at', DequeAtWorker) } self.methods = [self._method_dict[m] for m in self._method_dict] def match(self, class_type, method_name): if not is_specialization_of(class_type, 'deque'): return None method = self._method_dict.get(method_name) if method is None or not method.enabled: return None return method.worker_class(class_type.template_argument(0)) # Xmethods for std::forward_list class ForwardListWorkerBase(gdb.xmethod.XMethodMatcher): def __init__(self, val_type, node_type): self._val_type = val_type self._node_type = node_type def get_arg_types(self): return None class ForwardListEmptyWorker(ForwardListWorkerBase): def get_result_type(self, obj): return get_bool_type() def __call__(self, obj): return obj['_M_impl']['_M_head']['_M_next'] == 0 class ForwardListFrontWorker(ForwardListWorkerBase): def get_result_type(self, obj): return self._val_type def __call__(self, obj): node = obj['_M_impl']['_M_head']['_M_next'].cast(self._node_type) val_address = node['_M_storage']['_M_storage'].address return val_address.cast(self._val_type.pointer()).dereference() class ForwardListMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): matcher_name = matcher_name_prefix + 'forward_list' gdb.xmethod.XMethodMatcher.__init__(self, matcher_name) self._method_dict = { 'empty': LibStdCxxXMethod('empty', ForwardListEmptyWorker), 'front': LibStdCxxXMethod('front', ForwardListFrontWorker) } self.methods = [self._method_dict[m] for m in self._method_dict] def match(self, class_type, method_name): if not is_specialization_of(class_type, 'forward_list'): return None method = self._method_dict.get(method_name) if method is None or not method.enabled: return None val_type = class_type.template_argument(0) node_type = gdb.lookup_type(str(class_type) + '::_Node').pointer() return method.worker_class(val_type, node_type) # Xmethods for std::list class ListWorkerBase(gdb.xmethod.XMethodWorker): def __init__(self, val_type, node_type): self._val_type = val_type self._node_type = node_type def get_arg_types(self): return None def get_value_from_node(self, node): node = node.dereference() if node.type.fields()[1].name == '_M_data': # C++03 implementation, node contains the value as a member return node['_M_data'] # C++11 implementation, node stores value in __aligned_membuf addr = node['_M_storage'].address return addr.cast(self._val_type.pointer()).dereference() class ListEmptyWorker(ListWorkerBase): def get_result_type(self, obj): return get_bool_type() def __call__(self, obj): base_node = obj['_M_impl']['_M_node'] if base_node['_M_next'] == base_node.address: return True else: return False class ListSizeWorker(ListWorkerBase): def get_result_type(self, obj): return get_std_size_type() def __call__(self, obj): begin_node = obj['_M_impl']['_M_node']['_M_next'] end_node = obj['_M_impl']['_M_node'].address size = 0 while begin_node != end_node: begin_node = begin_node['_M_next'] size += 1 return size class ListFrontWorker(ListWorkerBase): def get_result_type(self, obj): return self._val_type def __call__(self, obj): node = obj['_M_impl']['_M_node']['_M_next'].cast(self._node_type) return self.get_value_from_node(node) class ListBackWorker(ListWorkerBase): def get_result_type(self, obj): return self._val_type def __call__(self, obj): prev_node = obj['_M_impl']['_M_node']['_M_prev'].cast(self._node_type) return self.get_value_from_node(prev_node) class ListMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): gdb.xmethod.XMethodMatcher.__init__(self, matcher_name_prefix + 'list') self._method_dict = { 'empty': LibStdCxxXMethod('empty', ListEmptyWorker), 'size': LibStdCxxXMethod('size', ListSizeWorker), 'front': LibStdCxxXMethod('front', ListFrontWorker), 'back': LibStdCxxXMethod('back', ListBackWorker) } self.methods = [self._method_dict[m] for m in self._method_dict] def match(self, class_type, method_name): if not is_specialization_of(class_type, '(__cxx11::)?list'): return None method = self._method_dict.get(method_name) if method is None or not method.enabled: return None val_type = class_type.template_argument(0) node_type = gdb.lookup_type(str(class_type) + '::_Node').pointer() return method.worker_class(val_type, node_type) # Xmethods for std::vector class VectorWorkerBase(gdb.xmethod.XMethodWorker): def __init__(self, val_type): self._val_type = val_type def size(self, obj): if self._val_type.code == gdb.TYPE_CODE_BOOL: start = obj['_M_impl']['_M_start']['_M_p'] finish = obj['_M_impl']['_M_finish']['_M_p'] finish_offset = obj['_M_impl']['_M_finish']['_M_offset'] bit_size = start.dereference().type.sizeof * 8 return (finish - start) * bit_size + finish_offset else: return obj['_M_impl']['_M_finish'] - obj['_M_impl']['_M_start'] def get(self, obj, index): if self._val_type.code == gdb.TYPE_CODE_BOOL: start = obj['_M_impl']['_M_start']['_M_p'] bit_size = start.dereference().type.sizeof * 8 valp = start + index // bit_size offset = index % bit_size return (valp.dereference() & (1 << offset)) > 0 else: return obj['_M_impl']['_M_start'][index] class VectorEmptyWorker(VectorWorkerBase): def get_arg_types(self): return None def get_result_type(self, obj): return get_bool_type() def __call__(self, obj): return int(self.size(obj)) == 0 class VectorSizeWorker(VectorWorkerBase): def get_arg_types(self): return None def get_result_type(self, obj): return get_std_size_type() def __call__(self, obj): return self.size(obj) class VectorFrontWorker(VectorWorkerBase): def get_arg_types(self): return None def get_result_type(self, obj): return self._val_type def __call__(self, obj): return self.get(obj, 0) class VectorBackWorker(VectorWorkerBase): def get_arg_types(self): return None def get_result_type(self, obj): return self._val_type def __call__(self, obj): return self.get(obj, int(self.size(obj)) - 1) class VectorAtWorker(VectorWorkerBase): def get_arg_types(self): return get_std_size_type() def get_result_type(self, obj, index): return self._val_type def __call__(self, obj, index): size = int(self.size(obj)) if int(index) >= size: raise IndexError('Vector index "%d" should not be >= %d.' % ((int(index), size))) return self.get(obj, int(index)) class VectorSubscriptWorker(VectorWorkerBase): def get_arg_types(self): return get_std_size_type() def get_result_type(self, obj, subscript): return self._val_type def __call__(self, obj, subscript): return self.get(obj, int(subscript)) class VectorMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): gdb.xmethod.XMethodMatcher.__init__(self, matcher_name_prefix + 'vector') self._method_dict = { 'size': LibStdCxxXMethod('size', VectorSizeWorker), 'empty': LibStdCxxXMethod('empty', VectorEmptyWorker), 'front': LibStdCxxXMethod('front', VectorFrontWorker), 'back': LibStdCxxXMethod('back', VectorBackWorker), 'at': LibStdCxxXMethod('at', VectorAtWorker), 'operator[]': LibStdCxxXMethod('operator[]', VectorSubscriptWorker), } self.methods = [self._method_dict[m] for m in self._method_dict] def match(self, class_type, method_name): if not is_specialization_of(class_type, 'vector'): return None method = self._method_dict.get(method_name) if method is None or not method.enabled: return None return method.worker_class(class_type.template_argument(0)) # Xmethods for associative containers class AssociativeContainerWorkerBase(gdb.xmethod.XMethodWorker): def __init__(self, unordered): self._unordered = unordered def node_count(self, obj): if self._unordered: return obj['_M_h']['_M_element_count'] else: return obj['_M_t']['_M_impl']['_M_node_count'] def get_arg_types(self): return None class AssociativeContainerEmptyWorker(AssociativeContainerWorkerBase): def get_result_type(self, obj): return get_bool_type() def __call__(self, obj): return int(self.node_count(obj)) == 0 class AssociativeContainerSizeWorker(AssociativeContainerWorkerBase): def get_result_type(self, obj): return get_std_size_type() def __call__(self, obj): return self.node_count(obj) class AssociativeContainerMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self, name): gdb.xmethod.XMethodMatcher.__init__(self, matcher_name_prefix + name) self._name = name self._method_dict = { 'size': LibStdCxxXMethod('size', AssociativeContainerSizeWorker), 'empty': LibStdCxxXMethod('empty', AssociativeContainerEmptyWorker), } self.methods = [self._method_dict[m] for m in self._method_dict] def match(self, class_type, method_name): if not is_specialization_of(class_type, self._name): return None method = self._method_dict.get(method_name) if method is None or not method.enabled: return None unordered = 'unordered' in self._name return method.worker_class(unordered) # Xmethods for std::unique_ptr class UniquePtrGetWorker(gdb.xmethod.XMethodWorker): """ Implement std::unique_ptr::get() and std::unique_ptr::operator->(). """ def __init__(self, elem_type): self._is_array = elem_type.code == gdb.TYPE_CODE_ARRAY if self._is_array: self._elem_type = elem_type.target() else: self._elem_type = elem_type def get_arg_types(self): return None def get_result_type(self, obj): return self._elem_type.pointer() def _supports(self, method_name): # operator-> is not supported for unique_ptr return method_name == 'get' or not self._is_array def __call__(self, obj): impl_type = obj.dereference().type.fields()[0].type.tag # Check for new implementations first: if is_specialization_of(impl_type, '__uniq_ptr_(data|impl)'): tuple_member = obj['_M_t']['_M_t'] elif is_specialization_of(impl_type, 'tuple'): tuple_member = obj['_M_t'] else: return None tuple_impl_type = tuple_member.type.fields()[0].type # _Tuple_impl tuple_head_type = tuple_impl_type.fields()[1].type # _Head_base head_field = tuple_head_type.fields()[0] if head_field.name == '_M_head_impl': return tuple_member.cast(tuple_head_type)['_M_head_impl'] elif head_field.is_base_class: return tuple_member.cast(head_field.type) else: return None class UniquePtrDerefWorker(UniquePtrGetWorker): """Implement std::unique_ptr::operator*().""" def __init__(self, elem_type): UniquePtrGetWorker.__init__(self, elem_type) def get_result_type(self, obj): return self._elem_type def _supports(self, method_name): # operator* is not supported for unique_ptr return not self._is_array def __call__(self, obj): return UniquePtrGetWorker.__call__(self, obj).dereference() class UniquePtrSubscriptWorker(UniquePtrGetWorker): """Implement std::unique_ptr::operator[](size_t).""" def __init__(self, elem_type): UniquePtrGetWorker.__init__(self, elem_type) def get_arg_types(self): return get_std_size_type() def get_result_type(self, obj, index): return self._elem_type def _supports(self, method_name): # operator[] is only supported for unique_ptr return self._is_array def __call__(self, obj, index): return UniquePtrGetWorker.__call__(self, obj)[index] class UniquePtrMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): gdb.xmethod.XMethodMatcher.__init__(self, matcher_name_prefix + 'unique_ptr') self._method_dict = { 'get': LibStdCxxXMethod('get', UniquePtrGetWorker), 'operator->': LibStdCxxXMethod('operator->', UniquePtrGetWorker), 'operator*': LibStdCxxXMethod('operator*', UniquePtrDerefWorker), 'operator[]': LibStdCxxXMethod('operator[]', UniquePtrSubscriptWorker), } self.methods = [self._method_dict[m] for m in self._method_dict] def match(self, class_type, method_name): if not is_specialization_of(class_type, 'unique_ptr'): return None method = self._method_dict.get(method_name) if method is None or not method.enabled: return None worker = method.worker_class(class_type.template_argument(0)) if worker._supports(method_name): return worker return None # Xmethods for std::shared_ptr class SharedPtrGetWorker(gdb.xmethod.XMethodWorker): """ Implements std::shared_ptr::get() and std::shared_ptr::operator->(). """ def __init__(self, elem_type): self._is_array = elem_type.code == gdb.TYPE_CODE_ARRAY if self._is_array: self._elem_type = elem_type.target() else: self._elem_type = elem_type def get_arg_types(self): return None def get_result_type(self, obj): return self._elem_type.pointer() def _supports(self, method_name): # operator-> is not supported for shared_ptr return method_name == 'get' or not self._is_array def __call__(self, obj): return obj['_M_ptr'] class SharedPtrDerefWorker(SharedPtrGetWorker): """Implement std::shared_ptr::operator*().""" def __init__(self, elem_type): SharedPtrGetWorker.__init__(self, elem_type) def get_result_type(self, obj): return self._elem_type def _supports(self, method_name): # operator* is not supported for shared_ptr return not self._is_array def __call__(self, obj): return SharedPtrGetWorker.__call__(self, obj).dereference() class SharedPtrSubscriptWorker(SharedPtrGetWorker): """Implement std::shared_ptr::operator[](size_t).""" def __init__(self, elem_type): SharedPtrGetWorker.__init__(self, elem_type) def get_arg_types(self): return get_std_size_type() def get_result_type(self, obj, index): return self._elem_type def _supports(self, method_name): # operator[] is only supported for shared_ptr return self._is_array def __call__(self, obj, index): # Check bounds if _elem_type is an array of known bound m = re.match(r'.*\[(\d+)]$', str(self._elem_type)) if m and index >= int(m.group(1)): raise IndexError('shared_ptr<%s> index "%d" should not be >= %d.' % (self._elem_type, int(index), int(m.group(1)))) return SharedPtrGetWorker.__call__(self, obj)[index] class SharedPtrUseCountWorker(gdb.xmethod.XMethodWorker): """Implement std::shared_ptr::use_count().""" def __init__(self, elem_type): pass def get_arg_types(self): return None def get_result_type(self, obj): return gdb.lookup_type('long') def _supports(self, method_name): return True def __call__(self, obj): refcounts = obj['_M_refcount']['_M_pi'] return refcounts['_M_use_count'] if refcounts else 0 class SharedPtrUniqueWorker(SharedPtrUseCountWorker): """Implement std::shared_ptr::unique().""" def __init__(self, elem_type): SharedPtrUseCountWorker.__init__(self, elem_type) def get_result_type(self, obj): return gdb.lookup_type('bool') def __call__(self, obj): return SharedPtrUseCountWorker.__call__(self, obj) == 1 class SharedPtrMethodsMatcher(gdb.xmethod.XMethodMatcher): def __init__(self): gdb.xmethod.XMethodMatcher.__init__(self, matcher_name_prefix + 'shared_ptr') self._method_dict = { 'get': LibStdCxxXMethod('get', SharedPtrGetWorker), 'operator->': LibStdCxxXMethod('operator->', SharedPtrGetWorker), 'operator*': LibStdCxxXMethod('operator*', SharedPtrDerefWorker), 'operator[]': LibStdCxxXMethod('operator[]', SharedPtrSubscriptWorker), 'use_count': LibStdCxxXMethod('use_count', SharedPtrUseCountWorker), 'unique': LibStdCxxXMethod('unique', SharedPtrUniqueWorker), } self.methods = [self._method_dict[m] for m in self._method_dict] def match(self, class_type, method_name): if not is_specialization_of(class_type, 'shared_ptr'): return None method = self._method_dict.get(method_name) if method is None or not method.enabled: return None worker = method.worker_class(class_type.template_argument(0)) if worker._supports(method_name): return worker return None def register_libstdcxx_xmethods(locus): gdb.xmethod.register_xmethod_matcher(locus, ArrayMethodsMatcher()) gdb.xmethod.register_xmethod_matcher(locus, ForwardListMethodsMatcher()) gdb.xmethod.register_xmethod_matcher(locus, DequeMethodsMatcher()) gdb.xmethod.register_xmethod_matcher(locus, ListMethodsMatcher()) gdb.xmethod.register_xmethod_matcher(locus, VectorMethodsMatcher()) gdb.xmethod.register_xmethod_matcher( locus, AssociativeContainerMethodsMatcher('set')) gdb.xmethod.register_xmethod_matcher( locus, AssociativeContainerMethodsMatcher('map')) gdb.xmethod.register_xmethod_matcher( locus, AssociativeContainerMethodsMatcher('multiset')) gdb.xmethod.register_xmethod_matcher( locus, AssociativeContainerMethodsMatcher('multimap')) gdb.xmethod.register_xmethod_matcher( locus, AssociativeContainerMethodsMatcher('unordered_set')) gdb.xmethod.register_xmethod_matcher( locus, AssociativeContainerMethodsMatcher('unordered_map')) gdb.xmethod.register_xmethod_matcher( locus, AssociativeContainerMethodsMatcher('unordered_multiset')) gdb.xmethod.register_xmethod_matcher( locus, AssociativeContainerMethodsMatcher('unordered_multimap')) gdb.xmethod.register_xmethod_matcher(locus, UniquePtrMethodsMatcher()) gdb.xmethod.register_xmethod_matcher(locus, SharedPtrMethodsMatcher()) PKr1]Ü¯ˆ}}python/libstdcxx/v6/__init__.pynu„[µü¤# Copyright (C) 2014-2025 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # Load the xmethods if GDB supports them. def gdb_has_xmethods(): try: import gdb.xmethod return True except ImportError: return False def register_libstdcxx_printers(obj): # Load the pretty-printers. from .printers import register_libstdcxx_printers register_libstdcxx_printers(obj) if gdb_has_xmethods(): from .xmethods import register_libstdcxx_xmethods register_libstdcxx_xmethods(obj) PKr1]C×Bºõµõµpython/libstdcxx/v6/printers.pynu„[µü¤# Pretty-printers for libstdc++. # Copyright (C) 2008-2025 Free Software Foundation, Inc. # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . import gdb import itertools import re import sys import errno import datetime # Python 2 + Python 3 compatibility code # Resources about compatibility: # # * : Documentation of the "six" module # FIXME: The handling of e.g. std::basic_string (at least on char) # probably needs updating to work with Python 3's new string rules. # # In particular, Python 3 has a separate type (called byte) for # bytestrings, and a special b"" syntax for the byte literals; the old # str() type has been redefined to always store Unicode text. # # We probably can't do much about this until this GDB PR is addressed: # if sys.version_info[0] > 2: # Python 3 stuff Iterator = object # Python 3 folds these into the normal functions. imap = map izip = zip # Also, int subsumes long long = int _utc_timezone = datetime.timezone.utc else: # Python 2 stuff class Iterator: """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: """ def next(self): return self.__next__() # In Python 2, we still need these from itertools from itertools import imap, izip # Python 2 does not provide the datetime.UTC singleton. class UTC(datetime.tzinfo): """Concrete tzinfo class representing the UTC time zone.""" def utcoffset(self, dt): return datetime.timedelta(0) def tzname(self, dt): return "UTC" def dst(self, dt): return datetime.timedelta(0) _utc_timezone = UTC() # Try to use the new-style pretty-printing if available. _use_gdb_pp = True try: import gdb.printing except ImportError: _use_gdb_pp = False # Try to install type-printers. _use_type_printing = False try: import gdb.types if hasattr(gdb.types, 'TypePrinter'): _use_type_printing = True except ImportError: pass # Use the base class if available. if hasattr(gdb, 'ValuePrinter'): printer_base = gdb.ValuePrinter else: printer_base = object # Starting with the type ORIG, search for the member type NAME. This # handles searching upward through superclasses. This is needed to # work around http://sourceware.org/bugzilla/show_bug.cgi?id=13615. def find_type(orig, name): typ = orig.strip_typedefs() while True: # Use Type.tag to ignore cv-qualifiers. PR 67440. search = '%s::%s' % (typ.tag, name) try: return gdb.lookup_type(search) except RuntimeError: pass # The type was not found, so try the superclass. We only need # to check the first superclass, so we don't bother with # anything fancier here. fields = typ.fields() if len(fields) and fields[0].is_base_class: typ = fields[0].type else: raise ValueError("Cannot find type %s::%s" % (str(orig), name)) _versioned_namespace = '__8::' def lookup_templ_spec(templ, *args): """ Lookup template specialization templ. """ t = '{}<{}>'.format(templ, ', '.join([str(a) for a in args])) try: return gdb.lookup_type(t) except gdb.error as e: # Type not found, try again in versioned namespace. global _versioned_namespace if _versioned_namespace not in templ: t = t.replace('::', '::' + _versioned_namespace, 1) try: return gdb.lookup_type(t) except gdb.error: # If that also fails, rethrow the original exception pass raise e # Use this to find container node types instead of find_type, # see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91997 for details. def lookup_node_type(nodename, containertype): """ Lookup specialization of template nodename corresponding to containertype. nodename - The name of a class template, as a String containertype - The container, as a gdb.Type Return a gdb.Type for the corresponding specialization of nodename, or None if the type cannot be found. e.g. lookup_node_type('_List_node', gdb.lookup_type('std::list')) will return a gdb.Type for the type std::_List_node. """ # If nodename is unqualified, assume it's in namespace std. if '::' not in nodename: nodename = 'std::' + nodename # Use either containertype's value_type or its first template argument. try: valtype = find_type(containertype, 'value_type') except: valtype = containertype.template_argument(0) valtype = valtype.strip_typedefs() try: return lookup_templ_spec(nodename, valtype) except gdb.error: # For debug mode containers the node is in std::__cxx1998. if is_member_of_namespace(nodename, 'std'): if is_member_of_namespace(containertype, 'std::__cxx1998', 'std::__debug', '__gnu_debug'): nodename = nodename.replace('::', '::__cxx1998::', 1) try: return lookup_templ_spec(nodename, valtype) except gdb.error: pass return None def is_member_of_namespace(typ, *namespaces): """ 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. """ if isinstance(typ, gdb.Type): typ = str(typ) typ = strip_versioned_namespace(typ) for namespace in namespaces: if typ.startswith(namespace + '::'): return True return False def is_specialization_of(x, template_name): """ Test whether a type is a specialization of the named class template. The type can be specified as a string or a gdb.Type object. The template should be the name of a class template as a string, without any 'std' qualification. """ global _versioned_namespace if isinstance(x, gdb.Type): x = x.tag template_name = '(%s)?%s' % (_versioned_namespace, template_name) return re.match('^std::%s<.*>$' % template_name, x) is not None def strip_versioned_namespace(typename): global _versioned_namespace return typename.replace(_versioned_namespace, '') def strip_fundts_namespace(typ): """Remove "fundamentals_vN" inline namespace from qualified type name.""" pattern = r'^std::experimental::fundamentals_v\d::' repl = 'std::experimental::' if sys.version_info[0] == 2: return re.sub(pattern, repl, typ, 1) else: # Technically this needs Python 3.1 but nobody should be using 3.0 return re.sub(pattern, repl, typ, count=1) def strip_inline_namespaces(type_str): """Remove known inline namespaces from the canonical name of a type.""" type_str = strip_versioned_namespace(type_str) type_str = type_str.replace('std::__cxx11::', 'std::') expt_ns = 'std::experimental::' for lfts_ns in ('fundamentals_v1', 'fundamentals_v2'): type_str = type_str.replace(expt_ns + lfts_ns + '::', expt_ns) fs_ns = expt_ns + 'filesystem::' type_str = type_str.replace(fs_ns + 'v1::', fs_ns) return type_str def get_template_arg_list(type_obj): """Return a type's template arguments as a list.""" n = 0 template_args = [] while True: try: template_args.append(type_obj.template_argument(n)) except: return template_args n += 1 class SmartPtrIterator(Iterator): """An iterator for smart pointer types with a single 'child' value.""" def __init__(self, val): self._val = val def __iter__(self): return self def __next__(self): if self._val is None: raise StopIteration self._val, val = None, self._val return ('get()', val) class SharedPointerPrinter(printer_base): """ Print a shared_ptr, weak_ptr, atomic, or atomic. """ def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val self._pointer = val['_M_ptr'] def children(self): return SmartPtrIterator(self._pointer) # Return the _Sp_counted_base<>* that holds the refcounts. def _get_refcounts(self): if self._typename == 'std::atomic': # A tagged pointer is stored as uintptr_t. ptr_val = self._val['_M_refcount']['_M_val']['_M_i'] ptr_val = ptr_val - (ptr_val % 2) # clear lock bit ptr_type = find_type(self._val['_M_refcount'].type, 'pointer') return ptr_val.cast(ptr_type) return self._val['_M_refcount']['_M_pi'] def to_string(self): state = 'empty' refcounts = self._get_refcounts() targ = self._val.type.template_argument(0) targ = strip_versioned_namespace(str(targ)) if refcounts != 0: usecount = refcounts['_M_use_count'] weakcount = refcounts['_M_weak_count'] if usecount == 0: state = 'expired, weak count %d' % weakcount else: state = 'use count %d, weak count %d' % ( usecount, weakcount - 1) return '%s<%s> (%s)' % (self._typename, targ, state) def _tuple_impl_get(val): """Return the tuple element stored in a _Tuple_impl base class.""" bases = val.type.fields() if not bases[-1].is_base_class: raise ValueError( "Unsupported implementation for std::tuple: %s" % str(val.type)) # Get the _Head_base base class: head_base = val.cast(bases[-1].type) fields = head_base.type.fields() if len(fields) == 0: raise ValueError( "Unsupported implementation for std::tuple: %s" % str(val.type)) if fields[0].name == '_M_head_impl': # The tuple element is the _Head_base::_M_head_impl data member. return head_base['_M_head_impl'] elif fields[0].is_base_class: # The tuple element is an empty base class of _Head_base. # Cast to that empty base class. return head_base.cast(fields[0].type) else: raise ValueError( "Unsupported implementation for std::tuple: %s" % str(val.type)) def tuple_get(n, val): """Return the result of std::get(val) on a std::tuple.""" tuple_size = len(get_template_arg_list(val.type)) if n > tuple_size: raise ValueError("Out of range index for std::get on std::tuple") # Get the first _Tuple_impl<0, T...> base class: node = val.cast(val.type.fields()[0].type) while n > 0: # Descend through the base classes until the Nth one. node = node.cast(node.type.fields()[0].type) n -= 1 return _tuple_impl_get(node) def unique_ptr_get(val): """Return the result of val.get() on a std::unique_ptr.""" # std::unique_ptr contains a std::tuple, # either as a direct data member _M_t (the old implementation) # or within a data member of type __uniq_ptr_data. impl_type = val.type.fields()[0].type.strip_typedefs() # Check for new implementations first: if is_specialization_of(impl_type, '__uniq_ptr_data') \ or is_specialization_of(impl_type, '__uniq_ptr_impl'): tuple_member = val['_M_t']['_M_t'] elif is_specialization_of(impl_type, 'tuple'): tuple_member = val['_M_t'] else: raise ValueError( "Unsupported implementation for unique_ptr: %s" % str(impl_type)) return tuple_get(0, tuple_member) class UniquePointerPrinter(printer_base): """Print a unique_ptr.""" def __init__(self, typename, val): self._val = val def children(self): return SmartPtrIterator(unique_ptr_get(self._val)) def to_string(self): t = self._val.type.template_argument(0) return 'std::unique_ptr<{}>'.format(str(t)) def get_value_from_aligned_membuf(buf, valtype): """Return the value held in a __gnu_cxx::__aligned_membuf.""" return buf['_M_storage'].address.cast(valtype.pointer()).dereference() def get_value_from_list_node(node): """Return the value held in an _List_node<_Val>.""" try: member = node.type.fields()[1].name if member == '_M_data': # C++03 implementation, node contains the value as a member return node['_M_data'] elif member == '_M_storage': # C++11 implementation, node stores value in __aligned_membuf valtype = node.type.template_argument(0) return get_value_from_aligned_membuf(node['_M_storage'], valtype) except: pass raise ValueError("Unsupported implementation for %s" % str(node.type)) class StdListPrinter(printer_base): """Print a std::list.""" class _iterator(Iterator): def __init__(self, nodetype, head): self._nodetype = nodetype self._base = head['_M_next'] self._head = head.address self._count = 0 def __iter__(self): return self def __next__(self): if self._base == self._head: raise StopIteration elt = self._base.cast(self._nodetype).dereference() self._base = elt['_M_next'] count = self._count self._count = self._count + 1 val = get_value_from_list_node(elt) return ('[%d]' % count, val) def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def children(self): nodetype = lookup_node_type('_List_node', self._val.type).pointer() return self._iterator(nodetype, self._val['_M_impl']['_M_node']) def to_string(self): headnode = self._val['_M_impl']['_M_node'] if headnode['_M_next'] == headnode.address: return 'empty %s' % (self._typename) return '%s' % (self._typename) class NodeIteratorPrinter(printer_base): def __init__(self, typename, val, contname, nodename): self._val = val self._typename = typename self._contname = contname self._nodetype = lookup_node_type(nodename, val.type) def to_string(self): if not self._val['_M_node']: return 'non-dereferenceable iterator for std::%s' % (self._contname) node = self._val['_M_node'].cast( self._nodetype.pointer()).dereference() return str(get_value_from_list_node(node)) class StdListIteratorPrinter(NodeIteratorPrinter): """Print std::list::iterator.""" def __init__(self, typename, val): NodeIteratorPrinter.__init__(self, typename, val, 'list', '_List_node') class StdFwdListIteratorPrinter(NodeIteratorPrinter): """Print std::forward_list::iterator.""" def __init__(self, typename, val): NodeIteratorPrinter.__init__(self, typename, val, 'forward_list', '_Fwd_list_node') class StdSlistPrinter(printer_base): """Print a __gnu_cxx::slist.""" class _iterator(Iterator): def __init__(self, nodetype, head): self._nodetype = nodetype self._base = head['_M_head']['_M_next'] self._count = 0 def __iter__(self): return self def __next__(self): if self._base == 0: raise StopIteration elt = self._base.cast(self._nodetype).dereference() self._base = elt['_M_next'] count = self._count self._count = self._count + 1 return ('[%d]' % count, elt['_M_data']) def __init__(self, typename, val): self._val = val def children(self): nodetype = lookup_node_type('__gnu_cxx::_Slist_node', self._val.type) return self._iterator(nodetype.pointer(), self._val) def to_string(self): if self._val['_M_head']['_M_next'] == 0: return 'empty __gnu_cxx::slist' return '__gnu_cxx::slist' class StdSlistIteratorPrinter(printer_base): """Print __gnu_cxx::slist::iterator.""" def __init__(self, typename, val): self._val = val def to_string(self): if not self._val['_M_node']: return 'non-dereferenceable iterator for __gnu_cxx::slist' nodetype = lookup_node_type( '__gnu_cxx::_Slist_node', self._val.type).pointer() return str(self._val['_M_node'].cast(nodetype).dereference()['_M_data']) class StdVectorPrinter(printer_base): """Print a std::vector.""" class _iterator(Iterator): def __init__(self, start, finish, bitvec): self._bitvec = bitvec if bitvec: self._item = start['_M_p'] self._so = 0 self._finish = finish['_M_p'] self._fo = finish['_M_offset'] itype = self._item.dereference().type self._isize = 8 * itype.sizeof else: self._item = start self._finish = finish self._count = 0 def __iter__(self): return self def __next__(self): count = self._count self._count = self._count + 1 if self._bitvec: if self._item == self._finish and self._so >= self._fo: raise StopIteration elt = bool(self._item.dereference() & (1 << self._so)) self._so = self._so + 1 if self._so >= self._isize: self._item = self._item + 1 self._so = 0 return ('[%d]' % count, elt) else: if self._item == self._finish: raise StopIteration elt = self._item.dereference() self._item = self._item + 1 return ('[%d]' % count, elt) def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val self._is_bool = val.type.template_argument( 0).code == gdb.TYPE_CODE_BOOL def children(self): return self._iterator(self._val['_M_impl']['_M_start'], self._val['_M_impl']['_M_finish'], self._is_bool) def to_string(self): start = self._val['_M_impl']['_M_start'] finish = self._val['_M_impl']['_M_finish'] end = self._val['_M_impl']['_M_end_of_storage'] if self._is_bool: start = self._val['_M_impl']['_M_start']['_M_p'] finish = self._val['_M_impl']['_M_finish']['_M_p'] fo = self._val['_M_impl']['_M_finish']['_M_offset'] itype = start.dereference().type bl = 8 * itype.sizeof length = bl * (finish - start) + fo capacity = bl * (end - start) return ('%s of length %d, capacity %d' % (self._typename, int(length), int(capacity))) else: return ('%s of length %d, capacity %d' % (self._typename, int(finish - start), int(end - start))) def display_hint(self): return 'array' class StdVectorIteratorPrinter(printer_base): """Print std::vector::iterator.""" def __init__(self, typename, val): self._val = val def to_string(self): if not self._val['_M_current']: return 'non-dereferenceable iterator for std::vector' return str(self._val['_M_current'].dereference()) class StdBitIteratorPrinter(printer_base): """Print std::vector's _Bit_iterator and _Bit_const_iterator.""" def __init__(self, typename, val): self._val = val def to_string(self): if not self._val['_M_p']: return 'non-dereferenceable iterator for std::vector' return bool(self._val['_M_p'].dereference() & (1 << self._val['_M_offset'])) class StdBitReferencePrinter(printer_base): """Print std::vector::reference.""" def __init__(self, typename, val): self._val = val def to_string(self): if not self._val['_M_p']: # PR libstdc++/115098 removed the reference default constructor # that this case relates to. New code should never need this, # but we still handle it for compatibility with old binaries. return 'invalid std::vector::reference' return bool(self._val['_M_p'].dereference() & (self._val['_M_mask'])) class StdTuplePrinter(printer_base): """Print a std::tuple.""" class _iterator(Iterator): @staticmethod def _is_nonempty_tuple(nodes): if len(nodes) == 2: if is_specialization_of(nodes[1].type, '__tuple_base'): return True elif len(nodes) == 1: return True elif len(nodes) == 0: return False raise ValueError( "Top of tuple tree does not consist of a single node.") def __init__(self, head): self._head = head # Set the base class as the initial head of the # tuple. nodes = self._head.type.fields() if self._is_nonempty_tuple(nodes): # Set the actual head to the first pair. self._head = self._head.cast(nodes[0].type) self._count = 0 def __iter__(self): return self def __next__(self): # Check for further recursions in the inheritance tree. # For a GCC 5+ tuple self._head is None after visiting all nodes: if not self._head: raise StopIteration nodes = self._head.type.fields() # For a GCC 4.x tuple there is a final node with no fields: if len(nodes) == 0: raise StopIteration # Check that this iteration has an expected structure. if len(nodes) > 2: raise ValueError( "Cannot parse more than 2 nodes in a tuple tree.") if len(nodes) == 1: # This is the last node of a GCC 5+ std::tuple. impl = self._head.cast(nodes[0].type) self._head = None else: # Either a node before the last node, or the last node of # a GCC 4.x tuple (which has an empty parent). # - Left node is the next recursion parent. # - Right node is the actual class contained in the tuple. # Process right node. impl = self._head.cast(nodes[1].type) # Process left node and set it as head. self._head = self._head.cast(nodes[0].type) self._count = self._count + 1 # Finally, check the implementation. If it is # wrapped in _M_head_impl return that, otherwise return # the value "as is". fields = impl.type.fields() if len(fields) < 1 or fields[0].name != "_M_head_impl": return ('[%d]' % (self._count - 1), impl) else: return ('[%d]' % (self._count - 1), impl['_M_head_impl']) def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def children(self): return self._iterator(self._val) def to_string(self): if len(self._val.type.fields()) == 0: return 'empty %s' % (self._typename) return '%s containing' % (self._typename) class StdStackOrQueuePrinter(printer_base): """Print a std::stack or std::queue.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._visualizer = gdb.default_visualizer(val['c']) def children(self): return self._visualizer.children() def to_string(self): return '%s wrapping: %s' % (self._typename, self._visualizer.to_string()) def display_hint(self): if hasattr(self._visualizer, 'display_hint'): return self._visualizer.display_hint() return None class RbtreeIterator(Iterator): """ Turn an RB-tree-based container (std::map, std::set etc.) into a Python iterable object. """ def __init__(self, rbtree): self._size = rbtree['_M_t']['_M_impl']['_M_node_count'] self._node = rbtree['_M_t']['_M_impl']['_M_header']['_M_left'] self._count = 0 def __iter__(self): return self def __len__(self): return int(self._size) def __next__(self): if self._count == self._size: raise StopIteration result = self._node self._count = self._count + 1 if self._count < self._size: # Compute the next node. node = self._node if node.dereference()['_M_right']: node = node.dereference()['_M_right'] while node.dereference()['_M_left']: node = node.dereference()['_M_left'] else: parent = node.dereference()['_M_parent'] while node == parent.dereference()['_M_right']: node = parent parent = parent.dereference()['_M_parent'] if node.dereference()['_M_right'] != parent: node = parent self._node = node return result def get_value_from_Rb_tree_node(node): """Return the value held in an _Rb_tree_node<_Val>.""" try: member = node.type.fields()[1].name if member == '_M_value_field': # C++03 implementation, node contains the value as a member return node['_M_value_field'] elif member == '_M_storage': # C++11 implementation, node stores value in __aligned_membuf valtype = node.type.template_argument(0) return get_value_from_aligned_membuf(node['_M_storage'], valtype) except: pass raise ValueError("Unsupported implementation for %s" % str(node.type)) # This is a pretty printer for std::_Rb_tree_iterator (which is # std::map::iterator), and has nothing to do with the RbtreeIterator # class above. class StdRbtreeIteratorPrinter(printer_base): """Print std::map::iterator, std::set::iterator, etc.""" def __init__(self, typename, val): self._val = val nodetype = lookup_node_type('_Rb_tree_node', self._val.type) self._link_type = nodetype.pointer() def to_string(self): if not self._val['_M_node']: return 'non-dereferenceable iterator for associative container' node = self._val['_M_node'].cast(self._link_type).dereference() return str(get_value_from_Rb_tree_node(node)) class StdDebugIteratorPrinter(printer_base): """Print a debug enabled version of an iterator.""" def __init__(self, typename, val): self._val = val # Just strip away the encapsulating __gnu_debug::_Safe_iterator # and return the wrapped iterator value. def to_string(self): base_type = gdb.lookup_type('__gnu_debug::_Safe_iterator_base') itype = self._val.type.template_argument(0) safe_seq = self._val.cast(base_type)['_M_sequence'] if not safe_seq: return str(self._val.cast(itype)) if self._val['_M_version'] != safe_seq['_M_version']: return "invalid iterator" return str(self._val.cast(itype)) def num_elements(num): """Return either "1 element" or "N elements" depending on the argument.""" return '1 element' if num == 1 else '%d elements' % num class StdMapPrinter(printer_base): """Print a std::map or std::multimap.""" # Turn an RbtreeIterator into a pretty-print iterator. class _iter(Iterator): def __init__(self, rbiter, type): self._rbiter = rbiter self._count = 0 self._type = type def __iter__(self): return self def __next__(self): if self._count % 2 == 0: n = next(self._rbiter) n = n.cast(self._type).dereference() n = get_value_from_Rb_tree_node(n) self._pair = n item = n['first'] else: item = self._pair['second'] result = ('[%d]' % self._count, item) self._count = self._count + 1 return result def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def to_string(self): return '%s with %s' % (self._typename, num_elements(len(RbtreeIterator(self._val)))) def children(self): node = lookup_node_type('_Rb_tree_node', self._val.type).pointer() return self._iter(RbtreeIterator(self._val), node) def display_hint(self): return 'map' class StdSetPrinter(printer_base): """Print a std::set or std::multiset.""" # Turn an RbtreeIterator into a pretty-print iterator. class _iter(Iterator): def __init__(self, rbiter, type): self._rbiter = rbiter self._count = 0 self._type = type def __iter__(self): return self def __next__(self): item = next(self._rbiter) item = item.cast(self._type).dereference() item = get_value_from_Rb_tree_node(item) # FIXME: this is weird ... what to do? # Maybe a 'set' display hint? result = ('[%d]' % self._count, item) self._count = self._count + 1 return result def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def to_string(self): return '%s with %s' % (self._typename, num_elements(len(RbtreeIterator(self._val)))) def children(self): node = lookup_node_type('_Rb_tree_node', self._val.type).pointer() return self._iter(RbtreeIterator(self._val), node) class StdBitsetPrinter(printer_base): """Print a std::bitset.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def to_string(self): # If template_argument handled values, we could print the # size. Or we could use a regexp on the type. return '%s' % (self._typename) def children(self): try: # An empty bitset may not have any members which will # result in an exception being thrown. words = self._val['_M_w'] except: return [] wtype = words.type # The _M_w member can be either an unsigned long, or an # array. This depends on the template specialization used. # If it is a single long, convert to a single element list. if wtype.code == gdb.TYPE_CODE_ARRAY: tsize = wtype.target().sizeof else: words = [words] tsize = wtype.sizeof nwords = wtype.sizeof / tsize result = [] byte = 0 while byte < nwords: w = words[byte] bit = 0 while w != 0: if (w & 1) != 0: # Another spot where we could use 'set'? result.append(('[%d]' % (byte * tsize * 8 + bit), 1)) bit = bit + 1 w = w >> 1 byte = byte + 1 return result class StdDequePrinter(printer_base): """Print a std::deque.""" class _iter(Iterator): def __init__(self, node, start, end, last, buffer_size): self._node = node self._p = start self._end = end self._last = last self._buffer_size = buffer_size self._count = 0 def __iter__(self): return self def __next__(self): if self._p == self._last: raise StopIteration result = ('[%d]' % self._count, self._p.dereference()) self._count = self._count + 1 # Advance the 'cur' pointer. self._p = self._p + 1 if self._p == self._end: # If we got to the end of this bucket, move to the # next bucket. self._node = self._node + 1 self._p = self._node[0] self._end = self._p + self._buffer_size return result def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val self._elttype = val.type.template_argument(0) size = self._elttype.sizeof if size < 512: self._buffer_size = int(512 / size) else: self._buffer_size = 1 def to_string(self): start = self._val['_M_impl']['_M_start'] end = self._val['_M_impl']['_M_finish'] delta_n = end['_M_node'] - start['_M_node'] - 1 delta_s = start['_M_last'] - start['_M_cur'] delta_e = end['_M_cur'] - end['_M_first'] size = self._buffer_size * delta_n + delta_s + delta_e return '%s with %s' % (self._typename, num_elements(long(size))) def children(self): start = self._val['_M_impl']['_M_start'] end = self._val['_M_impl']['_M_finish'] return self._iter(start['_M_node'], start['_M_cur'], start['_M_last'], end['_M_cur'], self._buffer_size) def display_hint(self): return 'array' class StdDequeIteratorPrinter(printer_base): """Print std::deque::iterator.""" def __init__(self, typename, val): self._val = val def to_string(self): if not self._val['_M_cur']: return 'non-dereferenceable iterator for std::deque' return str(self._val['_M_cur'].dereference()) class StdStringPrinter(printer_base): """Print a std::basic_string of some kind.""" def __init__(self, typename, val): self._val = val self._new_string = typename.find("::__cxx11::basic_string") != -1 def to_string(self): # Make sure &string works, too. type = self._val.type if type.code == gdb.TYPE_CODE_REF: type = type.target() # Calculate the length of the string so that to_string returns # the string according to length, not according to first null # encountered. ptr = self._val['_M_dataplus']['_M_p'] if self._new_string: length = self._val['_M_string_length'] # https://sourceware.org/bugzilla/show_bug.cgi?id=17728 ptr = ptr.cast(ptr.type.strip_typedefs()) else: realtype = type.unqualified().strip_typedefs() reptype = gdb.lookup_type(str(realtype) + '::_Rep').pointer() header = ptr.cast(reptype) - 1 length = header.dereference()['_M_length'] if hasattr(ptr, "lazy_string"): return ptr.lazy_string(length=length) return ptr.string(length=length) def display_hint(self): return 'string' def access_streambuf_ptrs(streambuf): """Access the streambuf put area pointers.""" pbase = streambuf['_M_out_beg'] pptr = streambuf['_M_out_cur'] egptr = streambuf['_M_in_end'] return pbase, pptr, egptr class StdStringBufPrinter(printer_base): """Print a std::basic_stringbuf.""" def __init__(self, _, val): self._val = val def to_string(self): (pbase, pptr, egptr) = access_streambuf_ptrs(self._val) # Logic from basic_stringbuf::_M_high_mark() if pptr: if not egptr or pptr > egptr: return pbase.string(length=pptr - pbase) else: return pbase.string(length=egptr - pbase) return self._val['_M_string'] def display_hint(self): return 'string' class StdStringStreamPrinter(printer_base): """Print a std::basic_stringstream.""" def __init__(self, typename, val): self._val = val self._typename = typename # Check if the stream was redirected. This is essentially: # val['_M_streambuf'] != val['_M_stringbuf'].address # However, GDB can't resolve the virtual inheritance, so we do that # manually. basetype = [f.type for f in val.type.fields() if f.is_base_class][0] gdb.set_convenience_variable('__stream', val.cast(basetype).address) self._streambuf = gdb.parse_and_eval('$__stream->rdbuf()') self._was_redirected = self._streambuf != val['_M_stringbuf'].address def to_string(self): if self._was_redirected: return "%s redirected to %s" % ( self._typename, self._streambuf.dereference()) return self._val['_M_stringbuf'] def display_hint(self): if self._was_redirected: return None return 'string' class Tr1HashtableIterator(Iterator): def __init__(self, hashtable): self._buckets = hashtable['_M_buckets'] self._bucket = 0 self._bucket_count = hashtable['_M_bucket_count'] self._node_type = find_type(hashtable.type, '_Node').pointer() self._node = 0 while self._bucket != self._bucket_count: self._node = self._buckets[self._bucket] if self._node: break self._bucket = self._bucket + 1 def __iter__(self): return self def __next__(self): if self._node == 0: raise StopIteration node = self._node.cast(self._node_type) result = node.dereference()['_M_v'] self._node = node.dereference()['_M_next'] if self._node == 0: self._bucket = self._bucket + 1 while self._bucket != self._bucket_count: self._node = self._buckets[self._bucket] if self._node: break self._bucket = self._bucket + 1 return result class StdHashtableIterator(Iterator): def __init__(self, hashtable): self._node = hashtable['_M_before_begin']['_M_nxt'] valtype = hashtable.type.template_argument(1) cached = hashtable.type.template_argument(9).template_argument(0) node_type = lookup_templ_spec('std::__detail::_Hash_node', str(valtype), 'true' if cached else 'false') self._node_type = node_type.pointer() def __iter__(self): return self def __next__(self): if self._node == 0: raise StopIteration elt = self._node.cast(self._node_type).dereference() self._node = elt['_M_nxt'] valptr = elt['_M_storage'].address valptr = valptr.cast(elt.type.template_argument(0).pointer()) return valptr.dereference() class Tr1UnorderedSetPrinter(printer_base): """Print a std::unordered_set or tr1::unordered_set.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def _hashtable(self): if self._typename.startswith('std::tr1'): return self._val return self._val['_M_h'] def to_string(self): count = self._hashtable()['_M_element_count'] return '%s with %s' % (self._typename, num_elements(count)) @staticmethod def _format_count(i): return '[%d]' % i def children(self): counter = imap(self._format_count, itertools.count()) if self._typename.startswith('std::tr1'): return izip(counter, Tr1HashtableIterator(self._hashtable())) return izip(counter, StdHashtableIterator(self._hashtable())) class Tr1UnorderedMapPrinter(printer_base): """Print a std::unordered_map or tr1::unordered_map.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def _hashtable(self): if self._typename.startswith('std::tr1'): return self._val return self._val['_M_h'] def to_string(self): count = self._hashtable()['_M_element_count'] return '%s with %s' % (self._typename, num_elements(count)) @staticmethod def _flatten(list): for elt in list: for i in elt: yield i @staticmethod def _format_one(elt): return (elt['first'], elt['second']) @staticmethod def _format_count(i): return '[%d]' % i def children(self): counter = imap(self._format_count, itertools.count()) # Map over the hash table and flatten the result. if self._typename.startswith('std::tr1'): data = self._flatten( imap(self._format_one, Tr1HashtableIterator(self._hashtable()))) # Zip the two iterators together. return izip(counter, data) data = self._flatten( imap(self._format_one, StdHashtableIterator(self._hashtable()))) # Zip the two iterators together. return izip(counter, data) def display_hint(self): return 'map' class StdForwardListPrinter(printer_base): """Print a std::forward_list.""" class _iterator(Iterator): def __init__(self, nodetype, head): self._nodetype = nodetype self._base = head['_M_next'] self._count = 0 def __iter__(self): return self def __next__(self): if self._base == 0: raise StopIteration elt = self._base.cast(self._nodetype).dereference() self._base = elt['_M_next'] count = self._count self._count = self._count + 1 valptr = elt['_M_storage'].address valptr = valptr.cast(elt.type.template_argument(0).pointer()) return ('[%d]' % count, valptr.dereference()) def __init__(self, typename, val): self._val = val self._typename = strip_versioned_namespace(typename) def children(self): nodetype = lookup_node_type('_Fwd_list_node', self._val.type).pointer() return self._iterator(nodetype, self._val['_M_impl']['_M_head']) def to_string(self): if self._val['_M_impl']['_M_head']['_M_next'] == 0: return 'empty %s' % self._typename return '%s' % self._typename class SingleObjContainerPrinter(printer_base): """Base class for printers of containers of single objects.""" def __init__(self, val, viz, hint=None): self._contained_value = val self._visualizer = viz self._hint = hint def _recognize(self, type): """Return type as a string after applying type printers.""" global _use_type_printing if not _use_type_printing: return str(type) return gdb.types.apply_type_recognizers(gdb.types.get_type_recognizers(), type) or str(type) class _contained(Iterator): def __init__(self, val): self._val = val def __iter__(self): return self def __next__(self): if self._val is None: raise StopIteration retval = self._val self._val = None return ('[contained value]', retval) def children(self): if self._contained_value is None: return self._contained(None) if hasattr(self._visualizer, 'children'): return self._visualizer.children() return self._contained(self._contained_value) def display_hint(self): if (hasattr(self._visualizer, 'children') and hasattr(self._visualizer, 'display_hint')): # If contained value is a map we want to display in the same way. return self._visualizer.display_hint() return self._hint def function_pointer_to_name(f): """Find the name of the function referred to by the gdb.Value f, which should contain a function pointer from the program.""" # Turn the function pointer into an actual address. # This is needed to unpack ppc64 function descriptors. f = f.dereference().address if sys.version_info[0] == 2: # Older versions of GDB need to use long for Python 2, # because int(f) on 64-bit big-endian values raises a # gdb.error saying "Cannot convert value to int." f = long(f) else: f = int(f) try: # If the function can't be found older versions of GDB raise a # RuntimeError saying "Cannot locate object file for block." return gdb.block_for_pc(f).function.name except: return None class StdExpAnyPrinter(SingleObjContainerPrinter): """Print a std::any or std::experimental::any.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._typename = strip_fundts_namespace(self._typename) self._val = val self._contained_type = None contained_value = None visualizer = None mgr = self._val['_M_manager'] if mgr != 0: func = function_pointer_to_name(mgr) if not func: raise ValueError( "Invalid function pointer in %s" % (self._typename)) # We want to use this regular expression: # T::_Manager_xxx<.*>::_S_manage$T::_Op, const T\*, T::_Arg\*$ # where T is std::any or std::experimental::any. # But we need to account for variances in demangled names # between GDB versions, e.g. 'enum T::_Op' instead of 'T::_Op'. rx = ( r"({0}::_Manager_\w+<.*>)::_S_manage$" r"(enum )?{0}::_Op, (const {0}|{0} const) ?\*, " r"(union )?{0}::_Arg ?\*$" ).format(typename) m = re.match(rx, func) if not m: raise ValueError( "Unknown manager function in %s" % self._typename) mgrname = m.group(1) # FIXME need to expand 'std::string' so that gdb.lookup_type works if 'std::string' in mgrname: mgrtypes = [] for s in StdExpAnyPrinter._string_types(): try: x = re.sub(r"std::string(?!\w)", s, m.group(1)) # The following lookup might raise gdb.error if the # manager function was never instantiated for 's' in # the program, because there will be no such type. mgrtypes.append(gdb.lookup_type(x)) except gdb.error: pass if len(mgrtypes) != 1: # FIXME: this is unlikely in practice, but possible for # programs that use both old and new string types with # std::any in a single program. Can we do better? # Maybe find the address of each type's _S_manage and # compare to the address stored in _M_manager? raise ValueError( 'Cannot uniquely determine std::string type ' 'used in std::any' ) mgrtype = mgrtypes[0] else: mgrtype = gdb.lookup_type(mgrname) self._contained_type = mgrtype.template_argument(0) valptr = None if '::_Manager_internal' in mgrname: valptr = self._val['_M_storage']['_M_buffer'].address elif '::_Manager_external' in mgrname: valptr = self._val['_M_storage']['_M_ptr'] else: raise ValueError( "Unknown manager function in %s" % self._typename) contained_value = valptr.cast( self._contained_type.pointer()).dereference() visualizer = gdb.default_visualizer(contained_value) super(StdExpAnyPrinter, self).__init__(contained_value, visualizer) def to_string(self): if self._contained_type is None: return '%s [no contained value]' % self._typename desc = "%s containing " % self._typename if hasattr(self._visualizer, 'children'): return desc + self._visualizer.to_string() valtype = self._recognize(self._contained_type) return desc + strip_versioned_namespace(str(valtype)) @staticmethod def _string_types(): # This lookup for std::string might return the __cxx11 version, # but that's not necessarily the one used by the std::any # manager function we're trying to find. strings = {str(gdb.lookup_type('std::string').strip_typedefs())} # So also consider all the other possible std::string types! s = 'basic_string, std::allocator >' quals = ['std::', 'std::__cxx11::', 'std::' + _versioned_namespace] strings |= {q + s for q in quals} # set of unique strings return strings class StdExpOptionalPrinter(SingleObjContainerPrinter): """Print a std::optional or std::experimental::optional.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._typename = strip_fundts_namespace(self._typename) payload = val['_M_payload'] if self._typename.startswith('std::experimental'): engaged = val['_M_engaged'] contained_value = payload else: engaged = payload['_M_engaged'] contained_value = payload['_M_payload'] try: # Since GCC 9 contained_value = contained_value['_M_value'] except: pass visualizer = gdb.default_visualizer(contained_value) if not engaged: contained_value = None super(StdExpOptionalPrinter, self).__init__( contained_value, visualizer) def to_string(self): if self._contained_value is None: return "%s [no contained value]" % self._typename if hasattr(self._visualizer, 'children'): return "%s containing %s" % (self._typename, self._visualizer.to_string()) return self._typename class StdVariantPrinter(SingleObjContainerPrinter): """Print a std::variant.""" def __init__(self, typename, val): alternatives = get_template_arg_list(val.type) self._typename = strip_versioned_namespace(typename) self._index = val['_M_index'] if self._index >= len(alternatives): self._contained_type = None contained_value = None visualizer = None else: self._contained_type = alternatives[int(self._index)] addr = val['_M_u']['_M_first']['_M_storage'].address contained_value = addr.cast( self._contained_type.pointer()).dereference() visualizer = gdb.default_visualizer(contained_value) super(StdVariantPrinter, self).__init__( contained_value, visualizer, 'array') def to_string(self): if self._contained_value is None: return "%s [no contained value]" % self._typename if hasattr(self._visualizer, 'children'): return "%s [index %d] containing %s" % (self._typename, self._index, self._visualizer.to_string()) return "%s [index %d]" % (self._typename, self._index) class StdNodeHandlePrinter(SingleObjContainerPrinter): """Print a container node handle.""" def __init__(self, typename, val): self._value_type = val.type.template_argument(1) nodetype = val.type.template_argument(2).template_argument(0) self._is_rb_tree_node = is_specialization_of( nodetype.name, '_Rb_tree_node') self._is_map_node = val.type.template_argument(0) != self._value_type nodeptr = val['_M_ptr'] if nodeptr: if self._is_rb_tree_node: contained_value = get_value_from_Rb_tree_node( nodeptr.dereference()) else: contained_value = get_value_from_aligned_membuf(nodeptr['_M_storage'], self._value_type) visualizer = gdb.default_visualizer(contained_value) else: contained_value = None visualizer = None optalloc = val['_M_alloc'] self._alloc = optalloc['_M_payload'] if optalloc['_M_engaged'] else None super(StdNodeHandlePrinter, self).__init__(contained_value, visualizer, 'array') def to_string(self): desc = 'node handle for ' if not self._is_rb_tree_node: desc += 'unordered ' if self._is_map_node: desc += 'map' else: desc += 'set' if self._contained_value: desc += ' with element' if hasattr(self._visualizer, 'children'): return "%s = %s" % (desc, self._visualizer.to_string()) return desc else: return 'empty %s' % desc class StdExpStringViewPrinter(printer_base): """ Print a std::basic_string_view or std::experimental::basic_string_view """ def __init__(self, typename, val): self._val = val def to_string(self): ptr = self._val['_M_str'] len = self._val['_M_len'] if hasattr(ptr, "lazy_string"): return ptr.lazy_string(length=len) return ptr.string(length=len) def display_hint(self): return 'string' class StdExpPathPrinter(printer_base): """Print a std::experimental::filesystem::path.""" def __init__(self, typename, val): self._val = val self._typename = typename start = self._val['_M_cmpts']['_M_impl']['_M_start'] finish = self._val['_M_cmpts']['_M_impl']['_M_finish'] self._num_cmpts = int(finish - start) def _path_type(self): t = str(self._val['_M_type']) if t[-9:] == '_Root_dir': return "root-directory" if t[-10:] == '_Root_name': return "root-name" return None def to_string(self): path = "%s" % self._val['_M_pathname'] if self._num_cmpts == 0: t = self._path_type() if t: path = '%s [%s]' % (path, t) return "experimental::filesystem::path %s" % path class _iterator(Iterator): def __init__(self, cmpts, pathtype): self._pathtype = pathtype self._item = cmpts['_M_impl']['_M_start'] self._finish = cmpts['_M_impl']['_M_finish'] self._count = 0 def __iter__(self): return self def __next__(self): if self._item == self._finish: raise StopIteration item = self._item.dereference() count = self._count self._count = self._count + 1 self._item = self._item + 1 path = item['_M_pathname'] t = StdExpPathPrinter(self._pathtype, item)._path_type() if not t: t = count return ('[%s]' % t, path) def children(self): return self._iterator(self._val['_M_cmpts'], self._typename) class StdPathPrinter(printer_base): """Print a std::filesystem::path.""" def __init__(self, typename, val): self._val = val self._typename = typename impl = unique_ptr_get(self._val['_M_cmpts']['_M_impl']) self._type = impl.cast(gdb.lookup_type('uintptr_t')) & 3 if self._type == 0: self._impl = impl else: self._impl = None def _path_type(self): t = str(self._type.cast(gdb.lookup_type(self._typename + '::_Type'))) if t[-9:] == '_Root_dir': return "root-directory" if t[-10:] == '_Root_name': return "root-name" return None def to_string(self): path = "%s" % self._val['_M_pathname'] if self._type != 0: t = self._path_type() if t: path = '%s [%s]' % (path, t) return "filesystem::path %s" % path class _iterator(Iterator): def __init__(self, impl, pathtype): self._pathtype = pathtype if impl: # We can't access _Impl::_M_size because _Impl is incomplete # so cast to int* to access the _M_size member at offset zero, int_type = gdb.lookup_type('int') cmpt_type = gdb.lookup_type(pathtype + '::_Cmpt') char_type = gdb.lookup_type('char') impl = impl.cast(int_type.pointer()) size = impl.dereference() #self._capacity = (impl + 1).dereference() if hasattr(gdb.Type, 'alignof'): sizeof_Impl = max(2 * int_type.sizeof, cmpt_type.alignof) else: sizeof_Impl = 2 * int_type.sizeof begin = impl.cast(char_type.pointer()) + sizeof_Impl self._item = begin.cast(cmpt_type.pointer()) self._finish = self._item + size self._count = 0 else: self._item = None self._finish = None def __iter__(self): return self def __next__(self): if self._item == self._finish: raise StopIteration item = self._item.dereference() count = self._count self._count = self._count + 1 self._item = self._item + 1 path = item['_M_pathname'] t = StdPathPrinter(self._pathtype, item)._path_type() if not t: t = count return ('[%s]' % t, path) def children(self): return self._iterator(self._impl, self._typename) class StdPairPrinter(printer_base): """Print a std::pair object, with 'first' and 'second' as children.""" def __init__(self, typename, val): self._val = val class _iter(Iterator): """An iterator for std::pair types. Returns 'first' then 'second'.""" def __init__(self, val): self._val = val self._which = 'first' def __iter__(self): return self def __next__(self): if self._which is None: raise StopIteration which = self._which if which == 'first': self._which = 'second' else: self._which = None return (which, self._val[which]) def children(self): return self._iter(self._val) def to_string(self): return None class StdCmpCatPrinter(printer_base): """Print a comparison category object.""" def __init__(self, typename, val): self._typename = typename[typename.rfind(':') + 1:] self._val = val['_M_value'] def to_string(self): if self._typename == 'strong_ordering' and self._val == 0: name = 'equal' else: names = {2: 'unordered', -1: 'less', 0: 'equivalent', 1: 'greater'} name = names[int(self._val)] return 'std::{}::{}'.format(self._typename, name) class StdErrorCodePrinter(printer_base): """Print a std::error_code or std::error_condition.""" _system_is_posix = None # Whether std::system_category() use errno values. def __init__(self, typename, val): self._val = val self._typename = strip_versioned_namespace(typename) # Do this only once ... if StdErrorCodePrinter._system_is_posix is None: try: import posix StdErrorCodePrinter._system_is_posix = True except ImportError: StdErrorCodePrinter._system_is_posix = False @staticmethod def _find_errc_enum(name): typ = gdb.lookup_type(name) if typ is not None and typ.code == gdb.TYPE_CODE_ENUM: return typ return None @classmethod def _find_standard_errc_enum(cls, name): for ns in ['', _versioned_namespace]: try: qname = 'std::{}{}'.format(ns, name) return cls._find_errc_enum(qname) except RuntimeError: pass @classmethod def _match_net_ts_category(cls, cat): net_cats = ['stream', 'socket', 'ip::resolver'] for c in net_cats: func = c + '_category()' for ns in ['', _versioned_namespace]: ns = 'std::{}experimental::net::v1'.format(ns) sym = gdb.lookup_symbol('{}::{}::__c'.format(ns, func))[0] if sym is not None: if cat == sym.value().address: name = 'net::' + func enum = cls._find_errc_enum('{}::{}_errc'.format(ns, c)) return (name, enum) return (None, None) @classmethod def _category_info(cls, cat): """Return details of a std::error_category.""" name = None enum = None is_errno = False # Try these first, or we get "warning: RTTI symbol not found" when # using cat.dynamic_type on the local class types for Net TS # categories. func, enum = cls._match_net_ts_category(cat) if func is not None: return (None, func, enum, is_errno) # This might give a warning for a program-defined category defined as # a local class, but there doesn't seem to be any way to avoid that. typ = cat.dynamic_type.target() # Shortcuts for the known categories defined by libstdc++. if typ.tag.endswith('::generic_error_category'): name = 'generic' is_errno = True if typ.tag.endswith('::system_error_category'): name = 'system' is_errno = cls._system_is_posix if typ.tag.endswith('::future_error_category'): name = 'future' enum = cls._find_standard_errc_enum('future_errc') if typ.tag.endswith('::io_error_category'): name = 'io' enum = cls._find_standard_errc_enum('io_errc') if name is None: try: # Want to call std::error_category::name() override, but it's # unsafe: https://sourceware.org/bugzilla/show_bug.cgi?id=28856 # gdb.set_convenience_variable('__cat', cat) # return '"%s"' % gdb.parse_and_eval('$__cat->name()').string() pass except: pass return (name, typ.tag, enum, is_errno) @staticmethod def _unqualified_name(name): """ Strip any nested-name-specifier from name to give an unqualified name. """ return name.split('::')[-1] def to_string(self): value = self._val['_M_value'] cat = self._val['_M_cat'] name, alt_name, enum, is_errno = self._category_info(cat) if value == 0: default_cats = {'error_code': 'system', 'error_condition': 'generic'} if name == default_cats[self._unqualified_name(self._typename)]: return self._typename + ' = { }' # default-constructed value strval = str(value) if is_errno and value != 0: try: strval = errno.errorcode[int(value)] except: pass elif enum is not None: strval = self._unqualified_name(str(value.cast(enum))) if name is not None: name = '"%s"' % name else: name = alt_name return '%s = {%s: %s}' % (self._typename, name, strval) class StdRegexStatePrinter(printer_base): """Print a state node in the NFA for a std::regex.""" def __init__(self, typename, val): self._val = val self._typename = typename def to_string(self): opcode = str(self._val['_M_opcode']) if opcode: opcode = opcode[25:] next_id = self._val['_M_next'] variants = {'repeat': 'alt', 'alternative': 'alt', 'subexpr_begin': 'subexpr', 'subexpr_end': 'subexpr', 'line_begin_assertion': None, 'line_end_assertion': None, 'word_boundary': 'neg', 'subexpr_lookahead': 'neg', 'backref': 'backref_index', 'match': None, 'accept': None, 'dummy': None, 'unknown': None } v = variants[opcode] s = "opcode={}, next={}".format(opcode, next_id) if v is not None and self._val['_M_' + v] is not None: s = "{}, {}={}".format(s, v, self._val['_M_' + v]) return "{%s}" % (s) class StdSpanPrinter(printer_base): """Print a std::span.""" class _iterator(Iterator): def __init__(self, begin, size): self._count = 0 self._begin = begin self._size = size def __iter__(self): return self def __next__(self): if self._count == self._size: raise StopIteration count = self._count self._count = self._count + 1 return '[%d]' % count, (self._begin + count).dereference() def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val size_max = gdb.parse_and_eval('static_cast(-1)') if val.type.template_argument(1) == size_max: self._size = val['_M_extent']['_M_extent_value'] else: self._size = val.type.template_argument(1) def to_string(self): return '%s of length %d' % (self._typename, self._size) def children(self): return self._iterator(self._val['_M_ptr'], self._size) def display_hint(self): return 'array' class StdInitializerListPrinter(printer_base): """Print a std::initializer_list.""" def __init__(self, typename, val): self._typename = typename self._val = val self._size = val['_M_len'] def to_string(self): return '%s of length %d' % (self._typename, self._size) def children(self): return StdSpanPrinter._iterator(self._val['_M_array'], self._size) def display_hint(self): return 'array' class StdAtomicPrinter(printer_base): """Print a std:atomic.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val self._shptr_printer = None self._value_type = self._val.type.template_argument(0) if self._value_type.tag is not None: typ = strip_versioned_namespace(self._value_type.tag) if (typ.startswith('std::shared_ptr<') or typ.startswith('std::weak_ptr<')): impl = val['_M_impl'] self._shptr_printer = SharedPointerPrinter(typename, impl) self.children = self._shptr_children def _shptr_children(self): return SmartPtrIterator(self._shptr_printer._pointer) def to_string(self): if self._shptr_printer is not None: return self._shptr_printer.to_string() if self._value_type.code == gdb.TYPE_CODE_INT: val = self._val['_M_i'] elif self._value_type.code == gdb.TYPE_CODE_FLT: val = self._val['_M_fp'] elif self._value_type.code == gdb.TYPE_CODE_PTR: val = self._val['_M_b']['_M_p'] elif self._value_type.code == gdb.TYPE_CODE_BOOL: val = self._val['_M_base']['_M_i'] else: val = self._val['_M_i'] return '%s<%s> = { %s }' % (self._typename, str(self._value_type), val) class StdFormatArgsPrinter(printer_base): """Print a std::basic_format_args.""" # TODO: add printer for basic_format_arg and print out children. # TODO: add printer for __format::_ArgStore. def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def to_string(self): targs = get_template_arg_list(self._val.type) char_type = get_template_arg_list(targs[0])[1] if char_type == gdb.lookup_type('char'): typ = 'std::format_args' elif char_type == gdb.lookup_type('wchar_t'): typ = 'std::wformat_args' else: typ = 'std::basic_format_args' size = self._val['_M_packed_size'] if size == 1: return "%s with 1 argument" % (typ) if size == 0: size = self._val['_M_unpacked_size'] return "%s with %d arguments" % (typ, size) class StdChronoDurationPrinter(printer_base): """Print a std::chrono::duration.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def _ratio(self): # TODO use reduced period i.e. duration::period period = self._val.type.template_argument(1) num = period.template_argument(0) den = period.template_argument(1) return (num, den) def _suffix(self): num, den = self._ratio() if num == 1: if den == 1: return 's' if den == 1000: return 'ms' if den == 1000000: return 'us' if den == 1000000000: return 'ns' elif den == 1: if num == 60: return 'min' if num == 3600: return 'h' if num == 86400: return 'd' return '[{}]s'.format(num) return "[{}/{}]s".format(num, den) def to_string(self): r = self._val['__r'] if r.type.strip_typedefs().code == gdb.TYPE_CODE_FLT: r = "%g" % r return "std::chrono::duration = {{ {}{} }}".format(r, self._suffix()) class StdChronoTimePointPrinter(printer_base): """Print a std::chrono::time_point.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def _clock(self): clock = self._val.type.template_argument(0) name = strip_versioned_namespace(clock.name) if name == 'std::chrono::_V2::system_clock' \ or name == 'std::chrono::system_clock': return ('std::chrono::sys_time', 0) # XXX need to remove leap seconds from utc, gps, and tai if name == 'std::chrono::utc_clock': return ('std::chrono::utc_time', None) # XXX if name == 'std::chrono::gps_clock': return ('std::chrono::gps_time', None) # XXX 315964809 if name == 'std::chrono::tai_clock': return ('std::chrono::tai_time', None) # XXX -378691210 if name == 'std::filesystem::__file_clock': return ('std::chrono::file_time', 6437664000) if name == 'std::chrono::local_t': return ('std::chrono::local_time', 0) return ('{} time_point'.format(name), None) def to_string(self, abbrev=False): clock, offset = self._clock() d = self._val['__d'] r = d['__r'] printer = StdChronoDurationPrinter(d.type.name, d) suffix = printer._suffix() time = '' if offset is not None: num, den = printer._ratio() secs = (r * num / den) + offset try: dt = datetime.datetime.fromtimestamp(secs, _utc_timezone) time = ' [{:%Y-%m-%d %H:%M:%S}]'.format(dt) except: pass s = '%d%s%s' % (r, suffix, time) if abbrev: return s return '%s = { %s }' % (clock, s) class StdChronoZonedTimePrinter(printer_base): """Print a std::chrono::zoned_time.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def to_string(self): zone = self._val['_M_zone'].dereference()['_M_name'] time = self._val['_M_tp'] printer = StdChronoTimePointPrinter(time.type.name, time) time = printer.to_string(True) return 'std::chrono::zoned_time = {{ {} {} }}'.format(zone, time) months = [None, 'January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December'] weekdays = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday'] class StdChronoCalendarPrinter(printer_base): """Print a std::chrono::day, std::chrono::month, std::chrono::year etc.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def to_string(self): val = self._val typ = self._typename if 'month' in typ and typ != 'std::chrono::year_month_day_last': m = val['_M_m'] if typ.startswith('std::chrono::year'): y = val['_M_y'] if typ == 'std::chrono::day': return '{}'.format(int(val['_M_d'])) if typ == 'std::chrono::month': if m < 1 or m >= len(months): return "%d is not a valid month" % m return months[m] if typ == 'std::chrono::year': return '{}y'.format(y) if typ == 'std::chrono::weekday': wd = val['_M_wd'] if wd < 0 or wd >= len(weekdays): return "%d is not a valid weekday" % wd return '{}'.format(weekdays[wd]) if typ == 'std::chrono::weekday_indexed': return '{}[{}]'.format(val['_M_wd'], int(val['_M_index'])) if typ == 'std::chrono::weekday_last': return '{}[last]'.format(val['_M_wd']) if typ == 'std::chrono::month_day': return '{}/{}'.format(m, val['_M_d']) if typ == 'std::chrono::month_day_last': return '{}/last'.format(m) if typ == 'std::chrono::month_weekday': return '{}/{}'.format(m, val['_M_wdi']) if typ == 'std::chrono::month_weekday_last': return '{}/{}'.format(m, val['_M_wdl']) if typ == 'std::chrono::year_month': return '{}/{}'.format(y, m) if typ == 'std::chrono::year_month_day': return '{}/{}/{}'.format(y, m, val['_M_d']) if typ == 'std::chrono::year_month_day_last': return '{}/{}'.format(y, val['_M_mdl']) if typ == 'std::chrono::year_month_weekday': return '{}/{}/{}'.format(y, m, val['_M_wdi']) if typ == 'std::chrono::year_month_weekday_last': return '{}/{}/{}'.format(y, m, val['_M_wdl']) if typ.startswith('std::chrono::hh_mm_ss'): fract = '' if val['fractional_width'] != 0: fract = '.{:0{}d}'.format(int(val['_M_ss']['_M_r']), int(val['fractional_width'])) h = int(val['_M_h']['__r']) m = int(val['_M_m']['__r']) s = int(val['_M_s']['__r']) if val['_M_is_neg']: h = -h return '{:02}:{:02}:{:02}{}'.format(h, m, s, fract) class StdChronoTimeZonePrinter(printer_base): """Print a chrono::time_zone or chrono::time_zone_link.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def to_string(self): str = '%s = %s' % (self._typename, self._val['_M_name']) if self._typename.endswith("_link"): str += ' -> %s' % (self._val['_M_target']) return str class StdChronoLeapSecondPrinter(printer_base): """Print a chrono::leap_second.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def to_string(self): date = self._val['_M_s']['__r'] neg = '+-'[date < 0] return '%s %d (%c)' % (self._typename, abs(date), neg) class StdChronoTzdbPrinter(printer_base): """Print a chrono::tzdb.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def to_string(self): return '%s %s' % (self._typename, self._val['version']) class StdChronoTimeZoneRulePrinter(printer_base): """Print a chrono::time_zone rule.""" def __init__(self, typename, val): self._typename = strip_versioned_namespace(typename) self._val = val def to_string(self): on = self._val['on'] kind = on['kind'] month = months[on['month']] suffixes = {1: 'st', 2: 'nd', 3: 'rd', 21: 'st', 22: 'nd', 23: 'rd', 31: 'st'} day = on['day_of_month'] ordinal_day = '{}{}'.format(day, suffixes.get(day, 'th')) if kind == 0: # DayOfMonth start = '{} {}'.format(month, ordinal_day) else: weekday = weekdays[on['day_of_week']] if kind == 1: # LastWeekDay start = 'last {} in {}'.format(weekday, month) else: if kind == 2: # LessEq direction = ('last', '<=') else: direction = ('first', '>=') day = on['day_of_month'] start = '{} {} {} {} {}'.format(direction[0], weekday, direction[1], month, ordinal_day) return 'time_zone rule {} from {} to {} starting on {}'.format( self._val['name'], self._val['from'], self._val['to'], start) class StdLocalePrinter(printer_base): """Print a std::locale.""" def __init__(self, typename, val): self._val = val self._typename = typename def to_string(self): names = self._val['_M_impl']['_M_names'] mod = '' if names[0] == 0: name = '*' else: cats = gdb.parse_and_eval(self._typename + '::_S_categories') ncat = gdb.parse_and_eval(self._typename + '::_S_categories_size') n = names[0].string() cat = cats[0].string() name = '{}={}'.format(cat, n) cat_names = {cat: n} i = 1 while i < ncat and names[i] != 0: n = names[i].string() cat = cats[i].string() name = '{};{}={}'.format(name, cat, n) cat_names[cat] = n i = i + 1 uniq_names = set(cat_names.values()) if len(uniq_names) == 1: name = n elif len(uniq_names) == 2: n1, n2 = (uniq_names) name_list = list(cat_names.values()) other = None if name_list.count(n1) == 1: name = n2 other = n1 elif name_list.count(n2) == 1: name = n1 other = n2 if other is not None: cat = next(c for c, n in cat_names.items() if n == other) mod = ' with "{}={}"'.format(cat, other) return 'std::locale = "{}"{}'.format(name, mod) class StdIntegralConstantPrinter(printer_base): """Print a std::true_type or std::false_type.""" def __init__(self, typename, val): self._val = val self._typename = typename def to_string(self): value_type = self._val.type.template_argument(0) value = self._val.type.template_argument(1) if value_type.code == gdb.TYPE_CODE_BOOL: if value: return "std::true_type" else: return "std::false_type" typename = strip_versioned_namespace(self._typename) return "{}<{}, {}>".format(typename, value_type, value) class StdTextEncodingPrinter(printer_base): """Print a std::text_encoding.""" def __init__(self, typename, val): self._val = val self._typename = typename def to_string(self): rep = self._val['_M_rep'].dereference() if rep['_M_id'] == 1: return self._val['_M_name'] if rep['_M_id'] == 2: return 'unknown' return rep['_M_name'] # A "regular expression" printer which conforms to the # "SubPrettyPrinter" protocol from gdb.printing. class RxPrinter(object): def __init__(self, name, function): super(RxPrinter, self).__init__() self.name = name self._function = function self.enabled = True def invoke(self, value): if not self.enabled: return None if value.type.code == gdb.TYPE_CODE_REF: if hasattr(gdb.Value, "referenced_value"): value = value.referenced_value() return self._function(self.name, value) # A pretty-printer that conforms to the "PrettyPrinter" protocol from # gdb.printing. It can also be used directly as an old-style printer. class Printer(object): def __init__(self, name): super(Printer, self).__init__() self.name = name self._subprinters = [] self._lookup = {} self.enabled = True self._compiled_rx = re.compile('^([a-zA-Z0-9_:]+)(<.*>)?$') def add(self, name, function): # A small sanity check. # FIXME if not self._compiled_rx.match(name): raise ValueError( 'libstdc++ programming error: "%s" does not match' % name) printer = RxPrinter(name, function) self._subprinters.append(printer) self._lookup[name] = printer # Add a name using _GLIBCXX_BEGIN_NAMESPACE_VERSION. def add_version(self, base, name, function): self.add(base + name, function) if '__cxx11' not in base: vbase = re.sub('^(std|__gnu_cxx)::', r'\g<0>%s' % _versioned_namespace, base) self.add(vbase + name, function) # Add a name using _GLIBCXX_BEGIN_NAMESPACE_CONTAINER. def add_container(self, base, name, function): self.add_version(base, name, function) self.add_version(base + '__cxx1998::', name, function) @staticmethod def get_basic_type(type): # If it points to a reference, get the reference. if type.code == gdb.TYPE_CODE_REF: type = type.target() # Get the unqualified type, stripped of typedefs. type = type.unqualified().strip_typedefs() return type.tag def __call__(self, val): typename = self.get_basic_type(val.type) if not typename: return None # All the types we match are template types, so we can use a # dictionary. match = self._compiled_rx.match(typename) if not match: return None basename = match.group(1) if val.type.code == gdb.TYPE_CODE_REF: if hasattr(gdb.Value, "referenced_value"): val = val.referenced_value() if basename in self._lookup: return self._lookup[basename].invoke(val) # Cannot find a pretty printer. Return None. return None libstdcxx_printer = None class TemplateTypePrinter(object): """ 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 >' with 'std::vector'. """ def __init__(self, name, defargs): self.name = name self._defargs = defargs self.enabled = True class _recognizer(object): """The recognizer class for TemplateTypePrinter.""" def __init__(self, name, defargs): self.name = name self._defargs = defargs # self._type_obj = None def recognize(self, type_obj): """ 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. """ if type_obj.tag is None: return None if not type_obj.tag.startswith(self.name): return None template_args = get_template_arg_list(type_obj) displayed_args = [] require_defaulted = False for n in range(len(template_args)): # The actual template argument in the type: targ = template_args[n] # The default template argument for the class template: defarg = self._defargs.get(n) if defarg is not None: # Substitute other template arguments into the default: defarg = defarg.format(*template_args) # Fail to recognize the type (by returning None) # unless the actual argument is the same as the default. try: if targ != gdb.lookup_type(defarg): return None except gdb.error: # Type lookup failed, just use string comparison: if targ.tag != defarg: return None # All subsequent args must have defaults: require_defaulted = True elif require_defaulted: return None else: # Recursively apply recognizers to the template argument # and add it to the arguments that will be displayed: displayed_args.append(self._recognize_subtype(targ)) # This assumes no class templates in the nested-name-specifier: template_name = type_obj.tag[0:type_obj.tag.find('<')] template_name = strip_inline_namespaces(template_name) return template_name + '<' + ', '.join(displayed_args) + '>' def _recognize_subtype(self, type_obj): """Convert a gdb.Type to a string by applying recognizers, or if that fails then simply converting to a string.""" if type_obj.code == gdb.TYPE_CODE_PTR: return self._recognize_subtype(type_obj.target()) + '*' if type_obj.code == gdb.TYPE_CODE_ARRAY: type_str = self._recognize_subtype(type_obj.target()) if str(type_obj.strip_typedefs()).endswith('[]'): return type_str + '[]' # array of unknown bound return "%s[%d]" % (type_str, type_obj.range()[1] + 1) if type_obj.code == gdb.TYPE_CODE_REF: return self._recognize_subtype(type_obj.target()) + '&' if hasattr(gdb, 'TYPE_CODE_RVALUE_REF'): if type_obj.code == gdb.TYPE_CODE_RVALUE_REF: return self._recognize_subtype(type_obj.target()) + '&&' type_str = gdb.types.apply_type_recognizers( gdb.types.get_type_recognizers(), type_obj) if type_str: return type_str return str(type_obj) def instantiate(self): """Return a recognizer object for this type printer.""" return self._recognizer(self.name, self._defargs) def add_one_template_type_printer(obj, name, defargs): """ 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 >' } """ printer = TemplateTypePrinter('std::' + name, defargs) gdb.types.register_type_printer(obj, printer) # Add type printer for same type in debug namespace: printer = TemplateTypePrinter('std::__debug::' + name, defargs) gdb.types.register_type_printer(obj, printer) if '__cxx11' not in name: # Add second type printer for same type in versioned namespace: ns = 'std::' + _versioned_namespace # PR 86112 Cannot use dict comprehension here: defargs = dict((n, d.replace('std::', ns)) for (n, d) in defargs.items()) printer = TemplateTypePrinter(ns + name, defargs) gdb.types.register_type_printer(obj, printer) # Add type printer for same type in debug namespace: printer = TemplateTypePrinter('std::__debug::' + name, defargs) gdb.types.register_type_printer(obj, printer) class FilteringTypePrinter(object): """ A type printer that uses typedef names for common template specializations. Args: template (str): The class template to recognize. name (str): The typedef-name that will be used instead. targ1 (str, optional): The first template argument. Defaults to None. Checks if a specialization of the class template 'template' is the same type as the typedef 'name', and prints it as 'name' instead. e.g. if an instantiation of std::basic_istream is the same type as std::istream then print it as std::istream. If targ1 is provided (not None), match only template specializations with this type as the first template argument, e.g. if template='basic_string' and targ1='char' then only match 'basic_string' and not 'basic_string'. This rejects non-matching specializations more quickly, without needing to do GDB type lookups. """ def __init__(self, template, name, targ1=None): self._template = template self.name = name self._targ1 = targ1 self.enabled = True class _recognizer(object): """The recognizer class for FilteringTypePrinter.""" def __init__(self, template, name, targ1): self._template = template self.name = name self._targ1 = targ1 self._type_obj = None def recognize(self, type_obj): """ If type_obj starts with self._template and is the same type as self.name then return self.name, otherwise None. """ if type_obj.tag is None: return None if self._type_obj is None: if self._targ1 is not None: s = '{}<{}'.format(self._template, self._targ1) if not type_obj.tag.startswith(s): # Filter didn't match. return None elif not type_obj.tag.startswith(self._template): # Filter didn't match. return None try: self._type_obj = gdb.lookup_type( self.name).strip_typedefs() except: pass if self._type_obj is None: return None t1 = gdb.types.get_basic_type(self._type_obj) t2 = gdb.types.get_basic_type(type_obj) if t1 == t2: return strip_inline_namespaces(self.name) # Workaround ambiguous typedefs matching both std:: and # std::__cxx11:: symbols. if self._template.split('::')[-1] == 'basic_string': s1 = self._type_obj.tag.replace('__cxx11::', '') s2 = type_obj.tag.replace('__cxx11::', '') if s1 == s2: return strip_inline_namespaces(self.name) return None def instantiate(self): """Return a recognizer object for this type printer.""" return self._recognizer(self._template, self.name, self._targ1) def add_one_type_printer(obj, template, name, targ1=None): printer = FilteringTypePrinter('std::' + template, 'std::' + name, targ1) gdb.types.register_type_printer(obj, printer) if '__cxx11' not in template: ns = 'std::' + _versioned_namespace printer = FilteringTypePrinter(ns + template, ns + name, targ1) gdb.types.register_type_printer(obj, printer) def register_type_printers(obj): global _use_type_printing if not _use_type_printing: return # Add type printers for typedefs std::string, std::wstring etc. for ch in (('', 'char'), ('w', 'wchar_t'), ('u8', 'char8_t'), ('u16', 'char16_t'), ('u32', 'char32_t')): add_one_type_printer(obj, 'basic_string', ch[0] + 'string', ch[1]) add_one_type_printer(obj, '__cxx11::basic_string', ch[0] + 'string', ch[1]) # Typedefs for __cxx11::basic_string used to be in namespace __cxx11: add_one_type_printer(obj, '__cxx11::basic_string', '__cxx11::' + ch[0] + 'string', ch[1]) add_one_type_printer(obj, 'basic_string_view', ch[0] + 'string_view', ch[1]) # Add type printers for typedefs std::istream, std::wistream etc. for ch in (('', 'char'), ('w', 'wchar_t')): for x in ('ios', 'streambuf', 'istream', 'ostream', 'iostream', 'filebuf', 'ifstream', 'ofstream', 'fstream'): add_one_type_printer(obj, 'basic_' + x, ch[0] + x, ch[1]) for x in ('stringbuf', 'istringstream', 'ostringstream', 'stringstream'): add_one_type_printer(obj, 'basic_' + x, ch[0] + x, ch[1]) # types are in __cxx11 namespace, but typedefs aren't: add_one_type_printer(obj, '__cxx11::basic_' + x, ch[0] + x, ch[1]) # Add type printers for typedefs regex, wregex, cmatch, wcmatch etc. for abi in ('', '__cxx11::'): for ch in (('', 'char'), ('w', 'wchar_t')): add_one_type_printer(obj, abi + 'basic_regex', abi + ch[0] + 'regex', ch[1]) for ch in ('c', 's', 'wc', 'ws'): add_one_type_printer( obj, abi + 'match_results', abi + ch + 'match') for x in ('sub_match', 'regex_iterator', 'regex_token_iterator'): add_one_type_printer(obj, abi + x, abi + ch + x) # Note that we can't have a printer for std::wstreampos, because # it is the same type as std::streampos. add_one_type_printer(obj, 'fpos', 'streampos') # Add type printers for typedefs. for dur in ('nanoseconds', 'microseconds', 'milliseconds', 'seconds', 'minutes', 'hours', 'days', 'weeks', 'years', 'months'): add_one_type_printer(obj, 'chrono::duration', 'chrono::' + dur) # Add type printers for typedefs. add_one_type_printer(obj, 'linear_congruential_engine', 'minstd_rand0') add_one_type_printer(obj, 'linear_congruential_engine', 'minstd_rand') add_one_type_printer(obj, 'mersenne_twister_engine', 'mt19937') add_one_type_printer(obj, 'mersenne_twister_engine', 'mt19937_64') add_one_type_printer(obj, 'subtract_with_carry_engine', 'ranlux24_base') add_one_type_printer(obj, 'subtract_with_carry_engine', 'ranlux48_base') add_one_type_printer(obj, 'discard_block_engine', 'ranlux24') add_one_type_printer(obj, 'discard_block_engine', 'ranlux48') add_one_type_printer(obj, 'shuffle_order_engine', 'knuth_b') # Add type printers for experimental::basic_string_view typedefs. ns = 'experimental::fundamentals_v1::' for ch in (('', 'char'), ('w', 'wchar_t'), ('u8', 'char8_t'), ('u16', 'char16_t'), ('u32', 'char32_t')): add_one_type_printer(obj, ns + 'basic_string_view', ns + ch[0] + 'string_view', ch[1]) # Do not show defaulted template arguments in class templates. add_one_template_type_printer(obj, 'unique_ptr', {1: 'std::default_delete<{0}>'}) add_one_template_type_printer(obj, 'deque', {1: 'std::allocator<{0}>'}) add_one_template_type_printer( obj, 'forward_list', {1: 'std::allocator<{0}>'}) add_one_template_type_printer(obj, 'list', {1: 'std::allocator<{0}>'}) add_one_template_type_printer( obj, '__cxx11::list', {1: 'std::allocator<{0}>'}) add_one_template_type_printer(obj, 'vector', {1: 'std::allocator<{0}>'}) add_one_template_type_printer(obj, 'map', {2: 'std::less<{0}>', 3: 'std::allocator>'}) add_one_template_type_printer(obj, 'multimap', {2: 'std::less<{0}>', 3: 'std::allocator>'}) add_one_template_type_printer(obj, 'set', {1: 'std::less<{0}>', 2: 'std::allocator<{0}>'}) add_one_template_type_printer(obj, 'multiset', {1: 'std::less<{0}>', 2: 'std::allocator<{0}>'}) add_one_template_type_printer(obj, 'unordered_map', {2: 'std::hash<{0}>', 3: 'std::equal_to<{0}>', 4: 'std::allocator>'}) add_one_template_type_printer(obj, 'unordered_multimap', {2: 'std::hash<{0}>', 3: 'std::equal_to<{0}>', 4: 'std::allocator>'}) add_one_template_type_printer(obj, 'unordered_set', {1: 'std::hash<{0}>', 2: 'std::equal_to<{0}>', 3: 'std::allocator<{0}>'}) add_one_template_type_printer(obj, 'unordered_multiset', {1: 'std::hash<{0}>', 2: 'std::equal_to<{0}>', 3: 'std::allocator<{0}>'}) def register_libstdcxx_printers(obj): """Register libstdc++ pretty-printers with objfile Obj.""" global _use_gdb_pp global libstdcxx_printer if _use_gdb_pp: gdb.printing.register_pretty_printer(obj, libstdcxx_printer) else: if obj is None: obj = gdb obj.pretty_printers.append(libstdcxx_printer) register_type_printers(obj) def build_libstdcxx_dictionary(): global libstdcxx_printer libstdcxx_printer = Printer("libstdc++-v6") # libstdc++ objects requiring pretty-printing. # In order from: # http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/a01847.html libstdcxx_printer.add_version('std::', 'basic_string', StdStringPrinter) libstdcxx_printer.add_version( 'std::__cxx11::', 'basic_string', StdStringPrinter) libstdcxx_printer.add_container('std::', 'bitset', StdBitsetPrinter) libstdcxx_printer.add_container('std::', 'deque', StdDequePrinter) libstdcxx_printer.add_container('std::', 'list', StdListPrinter) libstdcxx_printer.add_container('std::__cxx11::', 'list', StdListPrinter) libstdcxx_printer.add_container('std::', 'map', StdMapPrinter) libstdcxx_printer.add_container('std::', 'multimap', StdMapPrinter) libstdcxx_printer.add_container('std::', 'multiset', StdSetPrinter) libstdcxx_printer.add_version('std::', 'pair', StdPairPrinter) libstdcxx_printer.add_version('std::', 'priority_queue', StdStackOrQueuePrinter) libstdcxx_printer.add_version('std::', 'queue', StdStackOrQueuePrinter) libstdcxx_printer.add_version('std::', 'tuple', StdTuplePrinter) libstdcxx_printer.add_container('std::', 'set', StdSetPrinter) libstdcxx_printer.add_version('std::', 'stack', StdStackOrQueuePrinter) libstdcxx_printer.add_version('std::', 'unique_ptr', UniquePointerPrinter) libstdcxx_printer.add_container('std::', 'vector', StdVectorPrinter) # vector libstdcxx_printer.add_version('std::', 'locale', StdLocalePrinter) if hasattr(gdb.Value, 'dynamic_type'): libstdcxx_printer.add_version('std::', 'error_code', StdErrorCodePrinter) libstdcxx_printer.add_version('std::', 'error_condition', StdErrorCodePrinter) # Printer registrations for classes compiled with -D_GLIBCXX_DEBUG. libstdcxx_printer.add('std::__debug::bitset', StdBitsetPrinter) libstdcxx_printer.add('std::__debug::deque', StdDequePrinter) libstdcxx_printer.add('std::__debug::list', StdListPrinter) libstdcxx_printer.add('std::__debug::map', StdMapPrinter) libstdcxx_printer.add('std::__debug::multimap', StdMapPrinter) libstdcxx_printer.add('std::__debug::multiset', StdSetPrinter) libstdcxx_printer.add('std::__debug::set', StdSetPrinter) libstdcxx_printer.add('std::__debug::vector', StdVectorPrinter) # These are the TR1 and C++11 printers. # For array - the default GDB pretty-printer seems reasonable. libstdcxx_printer.add_version('std::', 'shared_ptr', SharedPointerPrinter) libstdcxx_printer.add_version('std::', 'weak_ptr', SharedPointerPrinter) libstdcxx_printer.add_container('std::', 'unordered_map', Tr1UnorderedMapPrinter) libstdcxx_printer.add_container('std::', 'unordered_set', Tr1UnorderedSetPrinter) libstdcxx_printer.add_container('std::', 'unordered_multimap', Tr1UnorderedMapPrinter) libstdcxx_printer.add_container('std::', 'unordered_multiset', Tr1UnorderedSetPrinter) libstdcxx_printer.add_container('std::', 'forward_list', StdForwardListPrinter) libstdcxx_printer.add_version( 'std::tr1::', 'shared_ptr', SharedPointerPrinter) libstdcxx_printer.add_version( 'std::tr1::', 'weak_ptr', SharedPointerPrinter) libstdcxx_printer.add_version('std::tr1::', 'unordered_map', Tr1UnorderedMapPrinter) libstdcxx_printer.add_version('std::tr1::', 'unordered_set', Tr1UnorderedSetPrinter) libstdcxx_printer.add_version('std::tr1::', 'unordered_multimap', Tr1UnorderedMapPrinter) libstdcxx_printer.add_version('std::tr1::', 'unordered_multiset', Tr1UnorderedSetPrinter) libstdcxx_printer.add_version('std::', 'initializer_list', StdInitializerListPrinter) libstdcxx_printer.add_version('std::', 'atomic', StdAtomicPrinter) libstdcxx_printer.add_version( 'std::', 'basic_stringbuf', StdStringBufPrinter) libstdcxx_printer.add_version( 'std::__cxx11::', 'basic_stringbuf', StdStringBufPrinter) for sstream in ('istringstream', 'ostringstream', 'stringstream'): libstdcxx_printer.add_version( 'std::', 'basic_' + sstream, StdStringStreamPrinter) libstdcxx_printer.add_version( 'std::__cxx11::', 'basic_' + sstream, StdStringStreamPrinter) libstdcxx_printer.add_version('std::chrono::', 'duration', StdChronoDurationPrinter) libstdcxx_printer.add_version('std::chrono::', 'time_point', StdChronoTimePointPrinter) libstdcxx_printer.add_version('std::', 'integral_constant', StdIntegralConstantPrinter) # std::regex components libstdcxx_printer.add_version('std::__detail::', '_State', StdRegexStatePrinter) # These are the C++11 printer registrations for -D_GLIBCXX_DEBUG cases. # The tr1 namespace containers do not have any debug equivalents, # so do not register printers for them. libstdcxx_printer.add('std::__debug::unordered_map', Tr1UnorderedMapPrinter) libstdcxx_printer.add('std::__debug::unordered_set', Tr1UnorderedSetPrinter) libstdcxx_printer.add('std::__debug::unordered_multimap', Tr1UnorderedMapPrinter) libstdcxx_printer.add('std::__debug::unordered_multiset', Tr1UnorderedSetPrinter) libstdcxx_printer.add('std::__debug::forward_list', StdForwardListPrinter) # Library Fundamentals TS components libstdcxx_printer.add_version('std::experimental::fundamentals_v1::', 'any', StdExpAnyPrinter) libstdcxx_printer.add_version('std::experimental::fundamentals_v1::', 'optional', StdExpOptionalPrinter) libstdcxx_printer.add_version('std::experimental::fundamentals_v1::', 'basic_string_view', StdExpStringViewPrinter) # Filesystem TS components libstdcxx_printer.add_version('std::experimental::filesystem::v1::', 'path', StdExpPathPrinter) libstdcxx_printer.add_version('std::experimental::filesystem::v1::__cxx11::', 'path', StdExpPathPrinter) libstdcxx_printer.add_version('std::filesystem::', 'path', StdPathPrinter) libstdcxx_printer.add_version('std::filesystem::__cxx11::', 'path', StdPathPrinter) # C++17 components libstdcxx_printer.add_version('std::', 'any', StdExpAnyPrinter) libstdcxx_printer.add_version('std::', 'optional', StdExpOptionalPrinter) libstdcxx_printer.add_version('std::', 'basic_string_view', StdExpStringViewPrinter) libstdcxx_printer.add_version('std::', 'variant', StdVariantPrinter) libstdcxx_printer.add_version('std::', '_Node_handle', StdNodeHandlePrinter) # C++20 components libstdcxx_printer.add_version( 'std::', 'partial_ordering', StdCmpCatPrinter) libstdcxx_printer.add_version('std::', 'weak_ordering', StdCmpCatPrinter) libstdcxx_printer.add_version('std::', 'strong_ordering', StdCmpCatPrinter) libstdcxx_printer.add_version('std::', 'span', StdSpanPrinter) libstdcxx_printer.add_version('std::', 'basic_format_args', StdFormatArgsPrinter) for c in ['day', 'month', 'year', 'weekday', 'weekday_indexed', 'weekday_last', 'month_day', 'month_day_last', 'month_weekday', 'month_weekday_last', 'year_month', 'year_month_day', 'year_month_day_last', 'year_month_weekday', 'year_month_weekday_last', 'hh_mm_ss']: libstdcxx_printer.add_version('std::chrono::', c, StdChronoCalendarPrinter) libstdcxx_printer.add_version('std::chrono::', 'time_zone', StdChronoTimeZonePrinter) libstdcxx_printer.add_version('std::chrono::', 'time_zone_link', StdChronoTimeZonePrinter) libstdcxx_printer.add_version('std::chrono::', 'zoned_time', StdChronoZonedTimePrinter) libstdcxx_printer.add_version('std::chrono::', 'leap_second', StdChronoLeapSecondPrinter) libstdcxx_printer.add_version( 'std::chrono::', 'tzdb', StdChronoTzdbPrinter) # libstdcxx_printer.add_version('std::chrono::(anonymous namespace)', 'Rule', # StdChronoTimeZoneRulePrinter) # C++26 components libstdcxx_printer.add_version('std::', 'text_encoding', StdTextEncodingPrinter) # Extensions. libstdcxx_printer.add_version('__gnu_cxx::', 'slist', StdSlistPrinter) if True: # These shouldn't be necessary, if GDB "print *i" worked. # But it often doesn't, so here they are. libstdcxx_printer.add_container('std::', '_List_iterator', StdListIteratorPrinter) libstdcxx_printer.add_container('std::', '_List_const_iterator', StdListIteratorPrinter) libstdcxx_printer.add_version('std::', '_Rb_tree_iterator', StdRbtreeIteratorPrinter) libstdcxx_printer.add_version('std::', '_Rb_tree_const_iterator', StdRbtreeIteratorPrinter) libstdcxx_printer.add_container('std::', '_Deque_iterator', StdDequeIteratorPrinter) libstdcxx_printer.add_container('std::', '_Deque_const_iterator', StdDequeIteratorPrinter) libstdcxx_printer.add_version('__gnu_cxx::', '__normal_iterator', StdVectorIteratorPrinter) libstdcxx_printer.add_container('std::', '_Bit_iterator', StdBitIteratorPrinter) libstdcxx_printer.add_container('std::', '_Bit_const_iterator', StdBitIteratorPrinter) libstdcxx_printer.add_container('std::', '_Bit_reference', StdBitReferencePrinter) libstdcxx_printer.add_version('__gnu_cxx::', '_Slist_iterator', StdSlistIteratorPrinter) libstdcxx_printer.add_container('std::', '_Fwd_list_iterator', StdFwdListIteratorPrinter) libstdcxx_printer.add_container('std::', '_Fwd_list_const_iterator', StdFwdListIteratorPrinter) # Debug (compiled with -D_GLIBCXX_DEBUG) printer # registrations. libstdcxx_printer.add('__gnu_debug::_Safe_iterator', StdDebugIteratorPrinter) build_libstdcxx_dictionary() PKr1]µ@JY€€:python/libstdcxx/__pycache__/__init__.cpython-36.opt-1.pycnu„[µü¤3 À¡hã@sdS)N©rrrú-/usr/share/gcc-8/python/libstdcxx/__init__.pyÚsPKr1]µ@JY€€4python/libstdcxx/__pycache__/__init__.cpython-36.pycnu„[µü¤3 À¡hã@sdS)N©rrrú-/usr/share/gcc-8/python/libstdcxx/__init__.pyÚsPKr1]“×2python/libstdcxx/__init__.pynu„[µü¤ PKr1]3,Ïxexe=python/libstdcxx/v6/__pycache__/printers.cpython-36.opt-1.pycnu„[µü¤PKr1]äÔeæŽæŽ7åepython/libstdcxx/v6/__pycache__/xmethods.cpython-36.pycnu„[µü¤PKr1] ÇBö66=2õpython/libstdcxx/v6/__pycache__/__init__.cpython-36.opt-1.pycnu„[µü¤PKr1]3,Ïxexe7Õ÷python/libstdcxx/v6/__pycache__/printers.cpython-36.pycnu„[µü¤PKr1]äÔeæŽæŽ=´]python/libstdcxx/v6/__pycache__/xmethods.cpython-36.opt-1.pycnu„[µü¤PKr1] ÇBö667ípython/libstdcxx/v6/__pycache__/__init__.cpython-36.pycnu„[µü¤PKr1]£ö…²qq¤ïpython/libstdcxx/v6/xmethods.pynu„[µü¤PKr1]Ü¯ˆ}}apython/libstdcxx/v6/__init__.pynu„[µü¤PKr1]C×BºõµõµÎepython/libstdcxx/v6/printers.pynu„[µü¤PKr1]µ@JY€€:python/libstdcxx/__pycache__/__init__.cpython-36.opt-1.pycnu„[µü¤PKr1]µ@JY€€4üpython/libstdcxx/__pycache__/__init__.cpython-36.pycnu„[µü¤PKr1]“×2àpython/libstdcxx/__init__.pynu„[µü¤PKC-