Operation   : Linux premium131.web-hosting.com 4.18.0-553.44.1.lve.el8.x86_64 #1 SMP Thu Mar 13 14:29:12 UTC 2025 x86_64
Software     : Apache
Server IP    : 162.0.232.56 | Your IP: 216.73.216.111
Domains      : 1034 Domain(s)
Permission   : [ 0755 ]

o

�=?h�~�@s�dZd
dl
Z
d
dlZd
dlZd
dlmZmZmZ
gd�
ZeeBeBZ	Gdd�de
�ZGdd�d�Zd	d
�Z
Gdd�d�Zd
d�Zdd�ZGdd�de�Zdd�Zdd�Zdd�ZdS)zDebugger basics�N)�CO_GENERATOR�CO_COROUTINE�CO_ASYNC_GENERATOR)�BdbQuit�Bdb�
Breakpointc
@seZ
dZd
ZdS)rz Exception to give up completely.N)�__name__�
__module__�__qualname__�__doc__�rr�*/opt/alt/python310/lib64/python3.10/bdb.pyr
s
rc@s�
eZ
dZd
Zd^dd�
Zdd�Zdd�Zd	d
�Zdd�Zd
d�Z	dd�Z
dd�Zdd�Zdd�Z
dd�Zdd�Zdd�Zdd�Zdd �Zd!d"�Zd#d$�Zd_d&d'�
Zd^d(d)�
Zd*d+�Zd,d-�Zd.d/�Zd^d0d1�
Zd2d3�Zd4d5�Zd6d7�Z		d`d9d:�
Zd;d<�Zd=d>�Z d?d@�Z!dAdB�Z"dCdD�Z#dEdF�Z$dGdH�Z%dIdJ�Z&dKdL�Z'dMdN�Z(dOdP�Z)dQdR�Z*dadTdU�
Z+dbdVdW�
Z,dbdXdY�
Z-dZd[�Z.d\d]�Z/dS)craGeneric Python debugger base class.

    This class takes care of details of the trace facility;
    a derived class should implement user interaction.
    The standard debugger class (pdb.Pdb) is an example.

    The optional skip argument must be an iterable of glob-style
    module name patterns.  The debugger will not step into frames
    that originate in a module that matches one of these patterns.
    Whether a frame is considered to originate in a certain module
    is determined by the __name__ in the frame globals.
    NcCs0|
rt|
�
n
d|_
i|_i|_d|_|��
dS�
N)�set�skip�breaks�fncache�frame_returning�_load_breaks)�selfrrrr
�__init__s




zBdb.__init__cCsR|
d
|
dd�dkr|
S|j�
|
�
}|s'tj�|
�
}tj�|�
}||j|
<|S)a%
Return canonical form of filename.

        For real filenames, the canonical form is a case-normalized (on
        case insensitive filesystems) absolute path.  'Filenames' with
        angle brackets, such as "<stdin>", generated in interactive
        mode, are returned unchanged.
        �
<�
����
>)r�get�os�path�abspath�normcase)r�filename�canonicrrr
r!'s







zBdb.canonicc
Cs&d
dl}
|
�
�
d|_|�dd�
dS)z5Set values of attributes as ready to start debugging.r
N)�	linecache�
checkcache�botframe�
_set_stopinfo)rr"rrr
�reset8s


z	Bdb.resetcCs�|jrd
S|dkr|�
|
�
S|dkr|�|
|�S|dkr"|�|
|�S|dkr,|�|
|�S|dkr3|jS|dkr:|jS|dkrA|jStd	t|�
�
|jS)
aODispatch a trace function for debugged frames based on the event.

        This function is installed as the trace function for debugged
        frames. Its return value is the new trace function, which is
        usually itself. The default implementation decides how to
        dispatch a frame, depending on the type of event (passed in as a
        string) that is about to be executed.

        The event can be one of the following:
            line: A new line of code is going to be executed.
            call: A function is about to be called or another code block
                  is entered.
            return: A function or other code block is about to return.
            exception: An exception has occurred.
            c_call: A C function is about to be called.
            c_return: A C function has returned.
            c_exception: A C function has raised an exception.

        For the Python events, specialized functions (see the dispatch_*()
        methods) are called.  For the C events, no action is taken.

        The arg parameter depends on the previous event.
        N�lineZcall�returnZ	exceptionZc_callZc_exceptionZc_returnz*bdb.Bdb.dispatch: unknown debugging event:)�quitting�
dispatch_line�
dispatch_call�dispatch_return�dispatch_exception�trace_dispatch�print�repr)r�frameZevent�argrrr
r.?s$

















zBdb.trace_dispatchcCs.|�|
�
s
|�
|
�
r|�|
�

|jrt�
|jS)
a	
Invoke user function and return trace function for line event.

        If the debugger stops on the current line, invoke
        self.user_line(). Raise BdbQuit if self.quitting is set.
        Return self.trace_dispatch to continue tracing in this scope.
        )�	stop_here�
break_here�	user_liner)rr.�rr1rrr
r*js




zBdb.dispatch_linecCsd|jd
ur|
j
|_|jS|�|
�
s|�|
�
sd
S|jr$|
jjt@r$|jS|�	|
|�
|j
r/t�
|jS)a
Invoke user function and return trace function for call event.

        If the debugger stops on this function call, invoke
        self.user_call(). Raise BdbQuit if self.quitting is set.
        Return self.trace_dispatch to continue tracing in this scope.
        N)r$�f_backr.r3�break_anywhere�	stopframe�f_code�co_flags�GENERATOR_AND_COROUTINE_FLAGS�	user_callr)r�rr1r2rrr
r+vs







zBdb.dispatch_callcCs�|�|
�
s
|
|j
kr>|jr|
jjt@r|jSz|
|_|�|
|�
Wd
|_nd
|_w|j	r.t
�
|j|
ur>|jdkr>|�d
d
�
|jS)a
Invoke user function and return trace function for return event.

        If the debugger stops on this function return, invoke
        self.user_return(). Raise BdbQuit if self.quitting is set.
        Return self.trace_dispatch to continue tracing in this scope.
        Nr)
r3�returnframer9r:r;r<r.r�user_returnr)r�
stoplinenor%r>rrr
r,�s







zBdb.dispatch_returncCs�|�|
�
r%|
j
jt@r|d
tur|ddus"|�|
|�
|jr"t�
|j
S|jrG|
|ju
rG|jj
jt@rG|d
tt	fvrG|�|
|�
|jrGt�
|j
S)a
Invoke user function and return trace function for exception event.

        If the debugger stops on this exception, invoke
        self.user_exception(). Raise BdbQuit if self.quitting is set.
        Return self.trace_dispatch to continue tracing in this scope.
        r
�N)r3r:r;r<�
StopIteration�user_exceptionr)rr9�
GeneratorExitr.r>rrr
r-�s




�
�


zBdb.dispatch_exceptioncCs.|
d
urdS|jD]}t
�
|
|�r
dSq	dS)z4Return True if module_name matches any skip pattern.NFT)r�fnmatch)rZmodule_name�patternrrr
�is_skipped_module�s




�zBdb.is_skipped_modulecCsN|jr|�
|
j�d
�
�
rdS|
|jur |jdkrdS|
j|jkS|js%dSdS)z>Return True if frame is below the starting frame in the stack.rFrT)rrH�	f_globalsrr9rA�f_linenor6rrr
r3�s
�








z
Bdb.stop_herecCs�|�|
j
j�
}||jv
rd
S|
j}||j|v
r%|
j
j}||j|v
r%d
St|||
�\}}|rB|j|_|r@|j	r@|�
t|j�
�

dSd
S)z�Return True if there is an effective breakpoint for this line.

        Check for line or function breakpoint and if in effect.
        Delete temporary breakpoints if effective() says to.
        FT)r!r:�co_filenamerrJ�co_firstlineno�	effective�numberZ	currentbp�	temporary�do_clear�str)rr1r �lineno�bp�flagrrr
r4�s












zBdb.break_herecCstd
�
�
)zlRemove temporary breakpoint.

        Must implement in derived classes or get NotImplementedError.
        z)subclass of bdb must implement do_clear())
�NotImplementedError)rr2rrr
rP�szBdb.do_clearcCs|�|
j
j�
|jvS)
zEReturn True if there is any breakpoint for frame's filename.
        )r!r:rKrr6rrr
r8�szBdb.break_anywherec
C�d
S)z&Called if we might stop in a function.Nr)rr1Z
argument_listrrr
r=
�z
Bdb.user_callc
CrV)z'Called when we stop or break at a line.Nrr6rrr
r5
rWz
Bdb.user_linec
CrV)z&Called when a return trap is set here.Nr)rr1Zreturn_valuerrr
r@
rWzBdb.user_returnc
CrV)z$Called when we stop on an exception.Nr)rr1�exc_inforrr
rD
rWzBdb.user_exceptionr
cCs|
|_||_
d
|_||_dS)z�Set the attributes for stopping.

        If stoplineno is greater than or equal to 0, then stop at line
        greater than or equal to the stopline.  If stoplineno is -1, then
        don't stop at all.
        FN)r9r?r)rA)rr9r?rArrr
r%
s


zBdb._set_stopinfocCs$|d
ur	|
jd}|�
|
|
|�
d
S)zxStop when the line with the lineno greater than the current one is
        reached or when returning from current frame.Nr)rJr%)rr1rRrrr
�	set_until$
s


z
Bdb.set_untilc
Cs0|jr|jj
}
|
r|
js|j|
_|�d
d
�
d
S)zStop after one line of code.N)rr7�f_tracer.r%)rZcaller_framerrr
�set_step,
s





zBdb.set_stepcCs|�|
d
�
d
S)z2Stop on the next line in or below the given frame.N)
r%r6rrr
�set_next8
szBdb.set_nextcCs0|
jj
t@r|�|
d
d�
d
S|�|
j|
�
d
S)z)Stop when returning from the given frame.Nr)r:r;r<r%r7r6rrr
�
set_return<
s
zBdb.set_returncCsN|
d
ur	t�
�j}
|��
|
r|j|
_|
|_|
j}
|
s|��
t�|j�

d
S)znStart debugging from frame.

        If frame is not specified, debugging starts from caller's frame.
        N)	�sys�	_getframer7r&r.rZr$r[�settracer6rrr
�	set_traceC
s






�
z
Bdb.set_tracec
Csd|�|j
d
d�
|js*t�d
�

t��j}
|
r,|
|j
u
r0|
`|
j}
|
r.|
|j
u
sd
Sd
Sd
Sd
Sd
S)z�Stop only at breakpoints or when finished.

        If there are no breakpoints, set the system trace function to None.
        Nr)r%r$rr^r`r_r7rZr6rrr
�set_continueR
s






��zBdb.set_continuec

Cs"|j|_
d
|_d|_t�d
�

d
S)zuSet quitting attribute to True.

        Raises BdbQuit exception in the next call to a dispatch_*() method.
        NT)r$r9r?r)r^r`�
rrrr
�set_quita
s


zBdb.set_quitcCs(|j�
|
g�}||v
r|�|�

d
Sd
S)z/Add breakpoint to breaks, if not already there.N)r�
setdefault�append)rr rRZ
bp_linenosrrr
�_add_to_breaksr
s

�zBdb._add_to_breaksFc	CsN|�|
�
}
d
dl
}|�|
|�}|sd|
|fS|�|
|�
t|
||||�}dS)z�Set a new breakpoint for filename:lineno.

        If lineno doesn't exist for the filename, return an error message.
        The filename should be in canonical form.
        r
NzLine %s:%d does not exist)r!r"�getlinergr)	rr rRrO�cond�funcnamer"r'rSrrr
�	set_breakx
s







z
Bdb.set_breakc
Cs$tj
��D]
\}
}|�|
|�
qd
S)aO
Apply all breakpoints (set in other instances) to this one.

        Populates this instance's breaks list from the Breakpoint class's
        list, which can have breakpoints set by another Bdb instance. This
        is necessary for interactive sessions to keep the breakpoints
        active across multiple calls to run().
        N)r�bplist�keysrg�rr rRrrr
r�
s
�zBdb._load_breakscCs8|
|ftj
v
r|j|
�|�

|j|
s|j|
=d
Sd
S)a
Prune breakpoints for filename:lineno.

        A list of breakpoints is maintained in the Bdb instance and in
        the Breakpoint class.  If a breakpoint in the Bdb instance no
        longer exists in the Breakpoint class, then it's removed from the
        Bdb instance.
        N)rrlr�removernrrr
�
_prune_breaks�
s




�zBdb._prune_breakscCsj|�|
�
}
|
|j
v
rd
|
S||j
|
v
rd|
|fStj|
|fdd�D]}|��
q&|�|
|�
dS)znDelete breakpoints for filename:lineno.

        If no breakpoints were set, return an error message.
        �There are no breakpoints in %szThere is no breakpoint at %s:%dN)r!rrrl�deleteMerp)rr rRrSrrr
�clear_break�
s









zBdb.clear_breakc
CsXz|�|
�
}Wnt
y
}
z
t|�
WYd
}~Sd
}~w
w|��
|�|j|j�
d
S)zxDelete a breakpoint by its index in Breakpoint.bpbynumber.

        If arg is invalid, return an error message.
        N)�get_bpbynumber�
ValueErrorrQrrrp�filer')rr2rS�errrrr
�clear_bpbynumber�
s


��

zBdb.clear_bpbynumbercCsX|�|
�
}
|
|j
v
rd
|
S|j
|
D]}tj|
|f}|D]}|��
qq|j
|
=dS)z`Delete all breakpoints in filename.

        If none were set, return an error message.
        rqN)r!rrrlrr)rr r'ZblistrSrrr
�clear_all_file_breaks�
s








�
zBdb.clear_all_file_breaksc
Cs,|jsd
St
jD]}
|
r|
��
qi|_dS)z]Delete all existing breakpoints.

        If none were set, return an error message.
        zThere are no breakpointsN)rr�
bpbynumberrr)rrSrrr
�clear_all_breaks�
s




�

zBdb.clear_all_breakscCsz|
std
�
�
zt
|
�
}Wnty


td|
�
d�wztj|}Wnty0


td|�
d�w|dur;td|�
�
|S)z�Return a breakpoint by its index in Breakpoint.bybpnumber.

        For invalid arg values or if the breakpoint doesn't exist,
        raise a ValueError.
        zBreakpoint number expectedz Non-numeric breakpoint number %sNz!Breakpoint number %d out of rangezBreakpoint %d already deleted)ru�intrrz�
IndexError)rr2rNrSrrr
rt�
s




�


�

zBdb.get_bpbynumbercCs"|�|
�
}
|
|j
vo||j
|
vS)
z9Return True if there is a breakpoint for filename:lineno.�r!rrnrrr
�	get_break�
s



�z
Bdb.get_breakcCs4|�|
�
}
|
|j
vr||j
|
vrtj|
|fpgS)
znReturn all breakpoints for filename:lineno.

        If no breakpoints are set, return an empty list.
        )r!rrrlrnrrr
�
get_breaks�
s



���zBdb.get_breakscCs"|�|
�
}
|
|j
vr|j
|
SgS)
zrReturn all lines with breakpoints for filename.

        If no breakpoints are set, return an empty list.
        r~)rr rrr
�get_file_breaks�
s




zBdb.get_file_breaksc


Cs|jS)
z$Return all breakpoints that are set.)
rrcrrr
�get_all_breaks	szBdb.get_all_breakscCs�g}|r|j|
ur|j
}|
d
u
r%|�|
|
jf�

|
|jurn|
j}
|
d
u
s|��
tdt|�
d�}|d
u
rF|�|j|j	f�

|j
}|d
u
s6|
d
urStdt|�
d�}||fS)z�Return a list of (frame, lineno) in a stack trace and a size.

        List starts with original calling frame, if there is one.
        Size may be number of frames above or below f.
        Nr
r)
�tb_frame�tb_nextrfrJr$r7�reverse�max�len�	tb_lineno)r�
f�
t�stack�
irrr
�	get_stacks$







�



�

z
Bdb.get_stack�: cCs�d
dl}d
dl
}|
\}}|�|jj�
}d||f}|jjr$||jj7}n|d7}|d7}d|jvrA|jd}	|d7}||�|	�
7}|du
rW|�|||j	�}
|
rW|||
�
�7}|S)a:
Return a string with information about a stack entry.

        The stack entry frame_lineno is a (frame, lineno) tuple.  The
        return string contains the canonical filename, the function name
        or '<lambda>', the input arguments, the return value, and the
        line of code (if it exists).

        r
Nz%s(%r)z<lambda>z()Z
__return__z->)r"�reprlibr!r:rK�co_name�f_localsr0rhrI�strip)rZframe_linenoZlprefixr"r�r1rRr �
sZrvr'rrr
�format_stack_entry's"	
















zBdb.format_stack_entryc	Cs�|d
urdd
l}|j
}|d
ur|}|��
t|
t�r t|
dd�}
t�|j�

z(zt	|
||�
Wn	t
y8


YnwWd|_t�d
�

d
SWd|_t�d
�

d
Sd|_t�d
�

w)z�Debug a statement executed via the exec() function.

        globals defaults to __main__.dict; locals defaults to globals.
        Nr
z<string>�execT)�__main__�__dict__r&�
isinstancerQ�compiler^r`r.r�rr))r�cmd�globals�localsr�rrr
�runGs,












��
�
�
zBdb.runc	Cs�|d
urdd
l}|j
}|d
ur|}|��
t�|j�

z%zt|
||�WWd|_t�d
�

Sty5


Yn
wWd|_t�d
�

d
Sd|_t�d
�

w)z�Debug an expression executed via the eval() function.

        globals defaults to __main__.dict; locals defaults to globals.
        Nr
T)	r�r�r&r^r`r.�evalr)r)r�exprr�r�r�rrr
�runeval]s&








�
�

�
zBdb.runevalcCs|�|
||�
d
S)z.For backwards-compatibility.  Defers to run().N)
r�)rr�r�r�rrr
�runctxqsz
Bdb.runctxc	Os~|��
t
�|j�

d
}z)z	|
|i|�
�
}Wn	ty


YnwWd|_t
�d
�

|SWd|_t
�d
�

|Sd|_t
�d
�

w)zWDebug a single function call.

        Return the result of the function call.
        NT)r&r^r`r.rr))r�func�args�kwds�resrrr
�runcallxs$





��


�


�
zBdb.runcallr)
r
�FNN)
r��NN)0rr	r
rrr!r&r.r*r+r,r-rHr3r4rPr8r=r5r@rDr%rYr[r\r]rarbrdrgrkrrprsrxryr{rtrr�r�r�r�r�r�r�r�r�rrrr
rs`


+	




�





 
rcCst��
�
d
S)z<Start debugging with a Bdb instance from the caller's frame.N)rrarrrr
ra�srac@sfeZ
dZd
ZdZiZdg
Zddd�
Zedd��
Z	d	d
�Z
dd�Zd
d�Zddd�
Z
dd�Zdd�ZdS)ra�Breakpoint class.

    Implements temporary breakpoints, ignore counts, disabling and
    (re)-enabling, and conditionals.

    Breakpoints are indexed by number through bpbynumber and by
    the (file, line) tuple using bplist.  The former points to a
    single instance of class Breakpoint.  The latter points to a
    list of such instances since there may be more than one
    breakpoint per line.

    When creating a breakpoint, its associated filename should be
    in canonical form.  If funcname is defined, a breakpoint hit will be
    counted when the first line of that function is executed.  A
    conditional breakpoint always counts a hit.
    rNFcCs�||_d|_
|
|_||_||_||_d
|_d|_d|_t	j
|_t	j
d7_
|j�
|�

|
|f|jvr?|j|
|f�
|�

dS|g
|j|
|f<dS)NTr
r)rj�func_first_executable_linervr'rOri�enabled�ignore�hitsr�nextrNrzrfrl)rrvr'rOrirjrrr
r�s











zBreakpoint.__init__cCsd
t_
it_dg
t_dS)Nr)rr�rlrzrrrr
�clearBreakpoints�s

zBreakpoint.clearBreakpointsc
CsB|j|j
f}
d
|j|j<|j|
�|�

|j|
s|j|
=d
Sd
S)z�Delete the breakpoint from the list associated to a file:line.

        If it is the last breakpoint in that position, it also deletes
        the entry for the file:line.
        N)rvr'rzrNrlro)r�indexrrr
rr�s



�zBreakpoint.deleteMec

C�
d
|_dS)zMark the breakpoint as enabled.TN�
r�rcrrr
�enable��
zBreakpoint.enablec

Cr�)z Mark the breakpoint as disabled.FNr�rcrrr
�disable�r�zBreakpoint.disablecCs"|
d
urtj
}
t|��|
d�
d
S)z�Print the output of bpformat().

        The optional out argument directs where the output is sent
        and defaults to standard output.
        N)
rv)r^�stdoutr/�bpformat)r�outrrr
�bpprint�s

zBreakpoint.bpprintc
Cs�|jrd
}
nd}
|j
r|
d}
n|
d}
d|j|
|j|jf}|jr*|d|jf
7}|jr5|d|jf
7}|jrK|jdkr@d	}nd
}|d|j|f7}|S)z�Return a string with information about the breakpoint.

        The information includes the breakpoint number, temporary
        status, file:line position, break condition, number of times to
        ignore, and number of times hit.

        zdel  zkeep zyes  zno   z%-4dbreakpoint   %s at %s:%dz
	stop only if %sz
	ignore next %d hitsrr��z"
	breakpoint already hit %d time%s)rOr�rNrvr'rir�r�)rZdispZretZssrrr
r��s&





�








zBreakpoint.bpformatc

Csd
|j|j
|jfS)z1Return a condensed description of the breakpoint.zbreakpoint %s at %s:%s)rNrvr'rcrrr
�__str__szBreakpoint.__str__r�r)rr	r
rr�rlrzr�staticmethodr�rrr�r�r�r�r�rrrr
r�s







rcCsN|js
|j
|
jkrd
SdS|
jj|jkrd
S|js|
j|_|j|
jkr%d
SdS)aV
Return True if break should happen here.

    Whether a break should happen depends on the way that b (the breakpoint)
    was set.  If it was set via line number, check if b.line is the same as
    the one in the frame.  If it was set via function name, check if this is
    the right function and if it is on the first executable line.
    FT)rjr'rJr:r�r�)�
br1rrr
�
checkfuncname	s

r�cCs�tj
||
f}|D]U}|jsq	t||�sq	|jd
7_|js2|jdkr,|jd
8_q	|df
Sz!t|j|j|j	�}|rR|jdkrK|jd
8_n|dfW
SWq	


|dfY
SdS)a=Return (active breakpoint, delete temporary flag) or (None, None) as
       breakpoint to act upon.

       The "active breakpoint" is the first entry in bplist[line, file] (which
       must exist) that is enabled, for which checkfuncname is True, and that
       has neither a False condition nor a positive ignore count.  The flag,
       meaning that a temporary breakpoint should be deleted, is False only
       when the condiion cannot be evaluated (in which case, ignore count is
       ignored).

       If no such entry exists, then (None, None) is returned.
    rr
TFr�)
rrlr�r�r�rir�r�rIr�)rvr'r1Z	possiblesr��valrrr
rM)s,















�
rMc@s,eZ
dZd
d�Zdd�Zdd�Zdd�Zd	S)
�TdbcCs |
jj
}|sd
}td||�
dS)N�???z+++ call)r:r�r/)rr1r��namerrr
r=_s


z
Tdb.user_callcCsTd
dl}|
j
j}|sd}|�|
j
j�
}|�||
j|
j�}td||
j|d|�	��
dS)Nr
r�z+++�
:)
r"r:r�r!rKrhrJrIr/r�)rr1r"r��fnr'rrr
r5cs





z
Tdb.user_linecCstd
|�
dS)Nz
+++ return�
r/)rr1Zretvalrrr
r@js
zTdb.user_returncCstd
|�
|�
�
dS)Nz
+++ exception)r/rb)rr1Z	exc_stuffrrr
rDls


zTdb.user_exceptionN)rr	r
r=r5r@rDrrrr
r�^s

r�c
Cs&td
|d�
t
|d�
}
td|
�
dS)Nzfoo(�
)�
zbar returned)r/�bar)�
n�
xrrr
�foops


r�c

Cstd
|d�
|dS)Nzbar(r�rBr�)
�
arrr
r�us

r�c
Cst�}|�
d
�

dS)Nzimport bdb; bdb.foo(10))r�r�)
r�rrr
�testys

r�)rrFr^r�inspectrrr�__all__r<�	Exceptionrrrarr�rMr�r�r�r�rrrr
�<module>
s*


}z 5