| Server IP : 216.92.14.13 / Your IP : 216.73.216.171 Web Server : Apache System : Linux vps4089.pairvps.com 5.15.0-190-generic #200-Ubuntu SMP Fri Aug 7 15:06:04 UTC 2026 x86_64 User : rmlac2fmr ( 1040637) PHP Version : 8.2.32 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : ON | Sudo : ON | Pkexec : ON Directory : /lib/scons/SCons/ |
Upload File : |
�
�b3Qc @ s d Z d Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l Z d d l
m Z d d l Z d d l
Z d d l Z d d l Z e j j Z e j j Z d e f d � � YZ d Z d Z d Z d � Z d
� Z y e j Z e j Z Wn e k
r$d � Z n
Xd � Z e j d
� Z d � Z d � Z! d � Z" d � Z# d � Z$ d � Z% d � Z& d � Z' d � Z( d e f d � � YZ) d e) f d � � YZ* d � Z+ d a- d � Z. d d � Z/ d e* f d � � YZ0 d! e) f d" � � YZ1 d# e1 e0 f d$ � � YZ2 d% e* f d& � � YZ3 d' e) f d( � � YZ4 d) e f d* � � YZ5 d+ e f d, � � YZ6 d S(- s� SCons.Action
This encapsulates information about executing any sort of action that
can build one or more target Nodes (typically files) from one or more
source Nodes (also typically files) given a specific Environment.
The base class here is ActionBase. The base class supplies just a few
OO utility methods and some generic methods for displaying information
about an Action in response to the various commands that control printing.
A second-level base class is _ActionAction. This extends ActionBase
by providing the methods that can be used to show and perform an
action. True Action objects will subclass _ActionAction; Action
factory class objects will subclass ActionBase.
The heavy lifting is handled by subclasses for the different types of
actions we might execute:
CommandAction
CommandGeneratorAction
FunctionAction
ListAction
The subclasses supply the following public interface methods used by
other modules:
__call__()
THE public interface, "calling" an Action object executes the
command or Python function. This also takes care of printing
a pre-substitution command for debugging purposes.
get_contents()
Fetches the "contents" of an Action for signature calculation
plus the varlist. This is what gets MD5 checksummed to decide
if a target needs to be rebuilt because its action changed.
genstring()
Returns a string representation of the Action *without*
command substitution, but allows a CommandGeneratorAction to
generate the right action based on the specified target,
source and env. This is used by the Signature subsystem
(through the Executor) to obtain an (imprecise) representation
of the Action operation for informative purposes.
Subclasses also supply the following methods for internal use within
this module:
__str__()
Returns a string approximation of the Action; no variable
substitution is performed.
execute()
The internal method that really, truly, actually handles the
execution of a command or Python function. This is used so
that the __call__() methods can take care of displaying any
pre-substitution representations, and *then* execute an action
without worrying about the specific Actions involved.
get_presig()
Fetches the "contents" of a subclass for signature calculation.
The varlist is added to this to produce the Action's contents.
strfunction()
Returns a substituted string representation of the Action.
This is used by the _ActionAction.show() command to display the
command/function that will be executed to generate the target(s).
There is a related independent ActionCaller class that looks like a
regular Action, and which serves as a wrapper for arbitrary functions
that we want to let the user specify the arguments to now, but actually
execute later (when an out-of-date check determines that it's needed to
be executed, for example). Objects of this class are returned by an
ActionFactory class that provides a __call__() method as a convenient
way for wrapping up the functions.
s5 src/engine/SCons/Action.py 2013/03/03 09:48:35 garyoi����N( t logInstanceCreationt _nullc B s e Z RS( ( t __name__t
__module__( ( ( s /usr/lib/scons/SCons/Action.pyR z s i i c C s' y | j � SWn t k
r" | SXd S( N( t rfilet AttributeError( t n( ( s /usr/lib/scons/SCons/Action.pyR � s
c C s | S( N( ( t s( ( s /usr/lib/scons/SCons/Action.pyt default_exitstatfunc� s c C s | S( N( ( t x( ( s /usr/lib/scons/SCons/Action.pyt <lambda>� s c C s� g } t | � } d } x} | | k r� | | } t | � } | t k r} | t k rp | j | | | d !� n | d } q | j | � | d } q Wd j | � S( Ni i i t ( t lent ordt
HAVE_ARGUMENTt
SET_LINENOt appendt join( t codet resultR t it ct op( ( s /usr/lib/scons/SCons/Action.pyt remove_set_lineno_codes� s
s ^['"](.*)['"]$c C sz y t | j � SWnb t k
ru y t | j j � SWqv t k
rq y t | � SWqr t k
rm t | � SXqv Xn Xd S( s? Return the signature contents of a callable Python object.
N( t _function_contentst im_funcR t __call__t _code_contents( t obj( ( s /usr/lib/scons/SCons/Action.pyt _callable_contents� s
c C s� y t | j � SWn� t k
r� y t | j j � SWq� t k
r� y t | � SWq� t k
r� y t | � SWq� t k
r� y t j | � SWq� t j t f k
r� t | � SXq� Xq� Xq� Xn Xd S( s� Return the signature contents of any Python object.
We have to handle the case where object contains a code object
since it can be pickled directly.
N(
R R R R R t picklet dumpst
PicklingErrort TypeErrort str( R ( ( s /usr/lib/scons/SCons/Action.pyt _object_contents� s
c C s g } | j d | j t | j � f � y- | j d t | j � t | j � f � Wn t k
rv | j d � n X| j d d j t t | j
d � � d � | j d d j t t | j � � d � | j d t t
| j � � d � d j | � S( s� Return the signature contents of a code object.
By providing direct access to the code object of the
function, Python makes this extremely easy. Hooray!
Unfortunately, older versions of Python include line
number indications in the compiled byte code. Boo!
So we remove the line number byte codes to prevent
recompilations from moving a Python function.
s %s,%ss ,%s,%ss ,0,0s ,(t ,i t )R ( R t co_argcountR t co_varnamest co_cellvarst co_freevarsR R t mapR# t co_constst co_namesR" R t co_code( R t contents( ( s /usr/lib/scons/SCons/Action.pyR � s #-
.*$c C s� t | j � g } | j rH | j d d j t t | j � � d � n
| j d � y | j pd g } Wn t k
r� g } n Xy& g | D] } t | j � ^ q� } Wn t k
r� g } n X| j d d j | � d � d j | � S( s, Return the signature contents of a function.s ,(R$ R% s ,()R (
R t func_codet
func_defaultsR R R* R# t func_closureR t
cell_contents( t funcR. t closureR t xxx( ( s /usr/lib/scons/SCons/Action.pyR
s -
&
c C s� t | � } t | � } | d k r( | S| d k r8 | St | t � r� t | t � rj t | j | j � St | j | g � Sn3 t | t � r� t | g | j � St | | g � Sd S( N( t Actiont Nonet
isinstancet
ListActiont list( t act1t act2t a1t a2( ( s /usr/lib/scons/SCons/Action.pyt
_actionAppend) s c C s | j d d � } t | � r* | f } n t | � | d <| r� | d } | d k sb t | � ro | | d <n+ t | � r� | | d <n t j j d � � t | � d k r� | d | d | d <q� n | j d t � t k r
| j d t � t k r
t j j d � � n d S(
s This converts any arguments after the action argument into
their equivalent keywords and adds them to the kw argument.
t varlisti t cmdstrt strfunctions� Invalid command display variable type. You must either pass a string or a callback which accepts (target, source, env) as parameters.i s8 Cannot have both strfunction and cmdstr args to Action()N( (
t gett is_Stringt tupleR7 t callablet SConst Errorst UserErrorR R ( t argst kwt vt
cmdstrfunc( ( s /usr/lib/scons/SCons/Action.pyt _do_create_keywords> s$
c C s4 t | t � r | St | � r, t | | � St | � r� y | d } | d =Wn t k
rf d } n X| rv t } n t } | | | � St | � r� t j
j | � } | r� t | | � St
| � j d � } t | � d k r� t | d | � St | | � St | t � s t | t � r0t d | � � n d S( sb This is the actual "implementation" for the
Action factory method, below. This handles the
fact that passing lists to Action() itself has
different semantics than passing lists as elements
of lists.
The former will create a ListAction, the latter
will create a CommandAction by converting the inner
list elements to strings.t generatori s
i s5 Don't know how to create an Action from a number (%s)N( R8 t
ActionBaset is_Listt
CommandActionRF t KeyErrort CommandGeneratorActiont FunctionActionRD RG t Utilt get_environment_vart
LazyActionR" t splitR t _do_create_list_actiont intt floatR! R7 ( t actRK t gent action_typet vart commands( ( s /usr/lib/scons/SCons/Action.pyt _do_create_actionY s2
c C sz g } x9 | D]1 } t | | � } | d k r
| j | � q
q
W| sR t g � St | � d k rl | d St | � Sd S( sh A factory for list actions. Convert the input list into Actions
and then wrap them in a ListAction.i i N( Rb R7 R R9 R ( R] RK t actst at aa( ( s /usr/lib/scons/SCons/Action.pyRZ � s
c O s3 t | | � t | � r& t | | � St | | � S( s A factory for action objects.( RN RQ RZ Rb ( R] RJ RK ( ( s /usr/lib/scons/SCons/Action.pyR6 � s
RP c B sh e Z d Z d � Z d � Z e Z d � Z d � Z d � Z d � Z d � Z
d
d � Z d � Z
RS( s� Base class for all types of action objects that can be held by
other objects (Builders, Executors, etc.) This provides the
common methods for manipulating and combining those actions.c C s t | j | � S( N( t cmpt __dict__( t selft other( ( s /usr/lib/scons/SCons/Action.pyt __cmp__� s c C s d S( N( R7 ( Rh t envt targett source( ( s /usr/lib/scons/SCons/Action.pyt no_batch_key� s c C s
t | � S( N( R" ( Rh Rl Rm Rk ( ( s /usr/lib/scons/SCons/Action.pyt genstring� s c C s� | j | | | � g } | j | | | � } t | � rE | f } n x, | D]$ } | j | j d | d � � qL Wd j | � S( Ns ${t }R ( t
get_presigt get_varlistRD R t substR ( Rh Rl Rm Rk R t vlRL ( ( s /usr/lib/scons/SCons/Action.pyt get_contents� s
"c C s
t | | � S( N( R? ( Rh Ri ( ( s /usr/lib/scons/SCons/Action.pyt __add__� s c C s
t | | � S( N( R? ( Rh Ri ( ( s /usr/lib/scons/SCons/Action.pyt __radd__� s c C s+ | | _ t | � j d � } d | _ | S( Ns
( t
presub_envR" RY R7 ( Rh Rk t lines( ( s /usr/lib/scons/SCons/Action.pyt presub_lines� s c C s | j S( N( R@ ( Rh Rl Rm Rk t executor( ( s /usr/lib/scons/SCons/Action.pyRr � s c C s | j S( sg
Returns the type of targets ($TARGETS, $CHANGED_TARGETS) used
by this action.
( t targets( Rh Rk R{ ( ( s /usr/lib/scons/SCons/Action.pyt get_targets� s N( R R t __doc__Rj Rn t batch_keyRo Ru Rv Rw Rz R7 Rr R} ( ( ( s /usr/lib/scons/SCons/Action.pyRP � s t
_ActionActionc B sS e Z d Z e e d e d d d d d � Z d � Z e e e e e d d � Z RS( s2 Base class for actions that create output objects.s $TARGETSc K s� | | _ | t k r9 | d k r- d | _ q9 | | _ n | | _ | | _ | | _ | sc t } n | | _ | | _ | r� t
| � s� d � }
|
} n t j j
| | d � n d S( Nc S s t | � t | � f S( N( t id( Rh Rk Rl Rm ( ( s /usr/lib/scons/SCons/Action.pyt default_batch_key� s R ( RA R R7 RB R@ t presubt chdirR t exitstatfuncR| RF RG RV t AddMethod( Rh RA RB R@ R� R� R� R R| RK R� ( ( s /usr/lib/scons/SCons/Action.pyt __init__� s" c C sJ y t j j t | d � � Wn% t k
rE t j j | d � n Xd S( Ns
( t syst stdoutt writet unicodet UnicodeDecodeError( Rh R Rl Rm Rk ( ( s /usr/lib/scons/SCons/Action.pyt print_cmd_line� s
c
C s� t | � s | g } n t | � s0 | g } n | t k r] | j } | t k r] t } q] n | t k ru | j } n | t k r� t } n | t k r� t } n | t k r� | j } n d }
| rAt j
� }
y t | j � } WqAt
k
r=t | � s>| r$t | j d j d j � } q:t | d j � } q>qAXn | r�| rh| j � } | j � } n d j t t | � � } d j | j | � � } d | | f }
t j j |
� n d } | r�| j r�| r�| j � } | j � } n y | j | | | | � } Wn& t k
r5| j | | | � } n X| r�| rYd t | � | } n y
| j } Wn t
k
r�| j } n X| d � } | s�| j } n | | | | | � q�n d } | rc| r�t j | � n zj | j | | | d | �} t | t! j" j# � r9| | j$ � } | r0| | _$ qE| } n | | � } Wd |
r_t j |
� n Xn | r�|
r�| d t |
� | | | � n | S( Ni s and s
u Building %s with action:
%s
s
os.chdir(%s)
t PRINT_CMD_LINE_FUNCR{ s os.chdir(%s)(% RQ R R� t print_actions_presubR� t
print_actionst execute_actionsR� R7 t ost getcwdR" t abspathR RD t batchesR| t dirt get_all_targetst get_all_sourcesR R* Rz R� R� R� RB R! t reprRC R� t executeR8 RG RH t
BuildErrort status( Rh Rl Rm Rk R� R� t showR� R� R{ t save_cwdt tt lt outt cmdRC t
print_funct statR ( ( s /usr/lib/scons/SCons/Action.pyR s�
( N( R R R~ R R7 R� R� R ( ( ( s /usr/lib/scons/SCons/Action.pyR� � s c C sc g } xM t t | � D]< } d | k s4 d | k rE d | d } n | j | � q Wd j | � S( s\ Takes a list of command line arguments and returns a pretty
representation for printing.t s t "( R* R" R R ( t cmd_listt clt arg( ( s /usr/lib/scons/SCons/Action.pyt _string_from_cmd_listZ s c C sM y | d SWn: t k
rH t sD d d l } | j j � d a n t SXd S( Nt ENVi����( RS t default_ENVt SCons.Environmentt Environment( Rk RG ( ( s /usr/lib/scons/SCons/Action.pyt get_default_ENVj s
t ignorec K s� | j d � } t | � r= | d k r= t t j � | d <n | j d � } t | � r} | d k r} t t j d � | d <n | j d � } t | � r� | d k r� t t j d � | d <n | j d d
� } | d
k r� t | � } n i } xj | j � D]\ \ } } t | � rIt j
j | � } t j j
t t | � � | | <q� t | � | | <q� W| | d <y t j | | � SWnB t k
r�} | d k r�� n d t f d � � Y}
|
| � SXd
S( s- Do common setup for a subprocess.Popen() callt stdint devnullR� t wt stderrRk t raiset
dummyPopenc B sL e Z d � Z d � Z d � Z d Z d e f d � � YZ e � Z Z
RS( c S s
| | _ d S( N( t exception( Rh t e( ( s /usr/lib/scons/SCons/Action.pyR� � s c S s d S( NR ( R R ( ( Rh ( ( s /usr/lib/scons/SCons/Action.pyt communicate� s c S s | j j S( N( R� t errno( Rh ( ( s /usr/lib/scons/SCons/Action.pyt wait� s t fc B s e Z d � Z d � Z RS( c S s d S( NR ( ( Rh ( ( s /usr/lib/scons/SCons/Action.pyt read� s c S s d S( NR ( ( Rh ( ( s /usr/lib/scons/SCons/Action.pyt readline� s ( R R R� R� ( ( ( s /usr/lib/scons/SCons/Action.pyR� � s N( R R R� R� R� R7 R� t objectR� R� R� ( ( ( s /usr/lib/scons/SCons/Action.pyR� � s N( RC RD t openR� R� R7 R� t itemsRQ RG RV t flatten_sequencet pathsepR R* R" t
subprocesst Popent EnvironmentErrorR� ( t scons_envR� t errorRK t ioR� t new_envt keyt valueR� R� ( ( s /usr/lib/scons/SCons/Action.pyt _subproc} s4 "
RR c B s\ e Z d Z d � Z d � Z d d � Z d d � Z d d � Z d d � Z d d � Z
RS( s$ Class for command-execution actions.c K s] t | d � t j | | � t | � rP t t t | � � rP t d � � qP n | | _ d S( Ns Action.CommandActions3 CommandAction should be given only a single command( R R� R� RQ R: t filterR! R� ( Rh R� RK ( ( s /usr/lib/scons/SCons/Action.pyR� � s
c C s5 t | j � r( d j t t | j � � St | j � S( NR� ( RQ R� R R* R" ( Rh ( ( s /usr/lib/scons/SCons/Action.pyt __str__� s c C s | r$ | j | j d d | �} n | j | j d | | � } d } d } x t r� y | d d d } Wn t k
r� d } n X| d k r� d } n | d k r� d } n P| d d d | d d <qN Wy' | d d s� | d d | d <n Wn t k
rn X| | | f S( Ni R{ t @i t -( t
subst_listR� R7 t Truet
IndexError( Rh Rl Rm Rk R{ R t silentR� R ( ( s /usr/lib/scons/SCons/Action.pyt process� s,
c
C s� | j d k r d S| j t k r~ d d l m } | rV | j | j | d | �} n | j | j | | | � } | r~ | Sn | j | | | | � \ } } } | r� d St | d � S( Ni����( t SUBST_RAWR{ R i ( RA R7 R t SCons.SubstR� Rs R� R� (
Rh Rl Rm Rk R{ R� R R� R� R� ( ( s /usr/lib/scons/SCons/Action.pyRB � s !c C s t j j } t j j } y | d } Wn# t k
rK t j j d � � n Xy | d } Wn# t k
r t j j d � � n. Xt | � r� | j | d d d d � �} n | j
d d
� � } t | � }
xs |
j � D]e \ } } t | � s� t
| � r-| | � } t j j t t | � � |
| <q@t | � |
| <q� q� W| re| j � } | j � } n | j | t t t | � � | | � \ }
} } x~ t t |
� D]m } | | | � } | | | | d | |
� } | r�| r�d | } t j j d
| d | d | d | � Sq�Wd S( sV Execute a command action.
This will handle lists of commands as well as individual commands,
because construction variable substitution may turn a single
"command" into a list. This means that this class can actually
handle lists of commands, even though that's not how we use it
externally.
t SHELLs$ Missing SHELL construction variable.t SPAWNs$ Missing SPAWN construction variable.t rawi t convc S s | S( N( ( R ( ( s /usr/lib/scons/SCons/Action.pyR
s t ESCAPEc S s | S( N( ( R ( ( s /usr/lib/scons/SCons/Action.pyR
s i s Error %st errstrR� t actiont command( RG t Substt escape_listRV R� RS RH RI RD Rs RC R� R� RQ R� R� R R* R" R� R� R� R: R R� R R� ( Rh Rl Rm Rk R{ R� R� t shellt spawnt escapeR� R� R� R� R� R� t cmd_lineR t msg( ( s /usr/lib/scons/SCons/Action.pyR� � sD
! " 0
c C s� d d l m } | j } t | � r@ d j t t | � � } n t | � } | rh | j | | d | �S| j | | | | � Sd S( s� Return the signature contents of this action's command line.
This strips $(-$) and everything in between the string,
since those parts don't affect signatures.
i����( t SUBST_SIGR� R{ N( R� R� R� RQ R R* R" t subst_target_source( Rh Rl Rm Rk R{ R� R� ( ( s /usr/lib/scons/SCons/Action.pyRq / s c C s2 | j d t � } t | � r@ | d d k r@ | j | � } n | sS | d
k rW g Sd d l m } | r� | j | j | d | �} n | j | j | | | � } g } x | D]w } | r� t | d � }
t j
|
� } | r� | j d � }
n | j |
� }
|
r*| j
| j j |
� � q*q� q� W| S( Nt IMPLICIT_COMMAND_DEPENDENCIESi t $t 0R7 i����( R� R{ i ( R� s None( RC R� RD Rs R� R� R� R� R" t strip_quotest matcht groupt WhereIsR t fst File( Rh Rl Rm Rk R{ t icdR� R� t resR� t dt m( ( s /usr/lib/scons/SCons/Action.pyt get_implicit_deps@ s(
#N( R R R~ R� R� R7 R� RB R� Rq R� ( ( ( s /usr/lib/scons/SCons/Action.pyRR � s ? RT c B s� e Z d Z d � Z d d � Z d � Z d � Z d d � Z e e e e e d d � Z
d d � Z d d � Z d d � Z
d
� Z RS( s$ Class for command-generator actions.c C sM t | d � | | _ | | _ | j d d � | _ | j d d � | _ d S( Ns Action.CommandGeneratorActionR@ R| s $TARGETS( ( R RO t gen_kwRC R@ R| ( Rh RO RK ( ( s /usr/lib/scons/SCons/Action.pyR� Y s
c C s� t | � s | g } n | r9 | j � } | j � } n | j d | d | d | d | � } t | | j � } | s� t j j d t | � � � n | S( NRl Rm Rk t
for_signaturesN Object returned from command generator: %s cannot be used to create an Action.(
RQ R� R� RO R6 R� RG RH RI R� ( Rh Rl Rm Rk R� R{ t rett gen_cmd( ( s /usr/lib/scons/SCons/Action.pyt _generate` s c C sg y
| j } Wn t k
r& d } n X| d k rE t j j � } n | j g g | d � } t | � S( Ni ( Rx R R7 RG t Defaultst DefaultEnvironmentR� R" ( Rh Rk R] ( ( s /usr/lib/scons/SCons/Action.pyR� r s
c C s% | j | | | d � j | | | � S( Ni ( R� R ( Rh Rk Rl Rm ( ( s /usr/lib/scons/SCons/Action.pyR | s c C s( | j | | | d | � j | | | � S( Ni ( R� Ro ( Rh Rl Rm Rk R{ ( ( s /usr/lib/scons/SCons/Action.pyRo s c
C s� | j | | | d | � }
|
d k rp t j j d t t t t | � � � t t t t | � � � f � � n |
| | | | | | | | | � S( Ni sG While building `%s': Cannot deduce file extension from source files: %s( R� R7 RG RH RI R� R: R* R" ( Rh Rl Rm Rk R� R� R� R� R� R{ R] ( ( s /usr/lib/scons/SCons/Action.pyR � s =c C s( | j | | | d | � j | | | � S( s� Return the signature contents of this action's command line.
This strips $(-$) and everything in between the string,
since those parts don't affect signatures.
i ( R� Rq ( Rh Rl Rm Rk R{ ( ( s /usr/lib/scons/SCons/Action.pyRq � s c C s( | j | | | d | � j | | | � S( Ni ( R� R� ( Rh Rl Rm Rk R{ ( ( s /usr/lib/scons/SCons/Action.pyR� � s c C s+ | j | | | d | � j | | | | � S( Ni ( R� Rr ( Rh Rl Rm Rk R{ ( ( s /usr/lib/scons/SCons/Action.pyRr � s c C s% | j d d | d | � j | | � S( Ni ( R� R7 R} ( Rh Rk R{ ( ( s /usr/lib/scons/SCons/Action.pyR} � s N( R R R~ R� R7 R� R� R Ro R R Rq R� Rr R} ( ( ( s /usr/lib/scons/SCons/Action.pyRT W s
RX c B sM e Z d � Z d � Z d � Z d d � Z d � Z d � Z d d � Z RS( c C sJ t | d � t j | d | d | � t j j | � | _ | | _ d S( Ns Action.LazyActions ${Rp ( R RR R� RG RV t to_StringR` R� ( Rh R` RK ( ( s /usr/lib/scons/SCons/Action.pyR� � s
c C s2 | j | j � } t | � r. d | k r. t St S( Ns
( RC R` RD RR RT ( Rh Rk R ( ( s /usr/lib/scons/SCons/Action.pyt get_parent_class� s c C sh | r | j | j d � } n d } t | | j � } | sd t j j d | j t | � f � � n | S( NR s0 $%s value %s cannot be used to create an Action.( RC R` R6 R� RG RH RI R� ( Rh Rk R R� ( ( s /usr/lib/scons/SCons/Action.pyt _generate_cache� s (c C s
| j | � S( N( R ( Rh Rl Rm Rk R� R{ ( ( s /usr/lib/scons/SCons/Action.pyR� � s c O s+ | j | � } | j | | | | | | � S( N( R R ( Rh Rl Rm Rk RJ RK R ( ( s /usr/lib/scons/SCons/Action.pyR � s c C s% | j | � } | j | | | | � S( N( R Rq ( Rh Rl Rm Rk R ( ( s /usr/lib/scons/SCons/Action.pyRq � s c C s( | j | � } | j | | | | | � S( N( R Rr ( Rh Rl Rm Rk R{ R ( ( s /usr/lib/scons/SCons/Action.pyRr � s N(
R R R� R R R7 R� R Rq Rr ( ( ( s /usr/lib/scons/SCons/Action.pyRX � s
RU c B sS e Z d Z d � Z d � Z d d � Z d � Z d d � Z d � Z d � Z
RS( s" Class for Python function actions.c C s� t | d � | | _ y t | � | _ WnD t k
ro y | j | _ Wqp t k
rk t | � | _ qp Xn Xt j | | � d S( Ns Action.FunctionAction(
R t execfunctionR t funccontentsR Ru t gcR# R� R� ( Rh R RK ( ( s /usr/lib/scons/SCons/Action.pyR� � s
c C sL y | j j SWn7 t k
rG y | j j j SWqH t k
rC d SXn Xd S( Nt unknown_python_function( R R R t __class__( Rh ( ( s /usr/lib/scons/SCons/Action.pyt
function_name� s
c C s | j d k r d S| j t k r~ d d l m } | rV | j | j | d | �} n | j | j | | | � } | r~ | Sn d � } y | j j } Wn t k
r� n- X| d k r� d St | � r� | | | | � S| j
� } | | � }
| | � } d | |
| f S( Ni����( R� R{ c S s' d � } d d j t | | � � d S( Nc S s: y
| j } Wn t k
r, t | � } n
X| � } | S( N( t str_for_displayR R� ( R R ( ( s /usr/lib/scons/SCons/Action.pyt quote s
t [s , t ]( R R* ( Rd R ( ( s /usr/lib/scons/SCons/Action.pyt array s s
%s(%s, %s)( RA R7 R R� R� Rs R RB R RF R ( Rh Rl Rm Rk R{ R� R R t strfunct namet tstrt sstr( ( s /usr/lib/scons/SCons/Action.pyRB � s,
c C s- | j � } | d k r% t | j � Sd | S( Nt ActionCallers %s(target, source, env)( R R" R ( Rh R ( ( s /usr/lib/scons/SCons/Action.pyR� s
c C se d } zT| r* | j � } | j � } n t t t | � � } y" | j d | d | d | � } WnO t k
ry } � n: t k
r� } � n% t k
r� } | } t
j � } n X| rUt j
j | | � } | | _ | | _ y | j | | | | � | _ Wn) t k
r*| j | | | � | _ n X| d rUt | d t � rU| � qUn | SWd ~ Xd S( NRl Rm Rk i ( NNN( R7 R� R� R: R* R R t KeyboardInterruptt
SystemExitt ExceptionR� t exc_infoRG RH t convert_to_BuildErrort nodeR� RB R� R! R8 R� ( Rh Rl Rm Rk R{ R t rsourcesR R� ( ( s /usr/lib/scons/SCons/Action.pyR� s8 "
c C s3 y | j | | | � SWn t k
r. | j SXd S( s6 Return the signature contents of this callable action.N( R R R ( Rh Rl Rm Rk ( ( s /usr/lib/scons/SCons/Action.pyRq J s
c C s g S( N( ( Rh Rl Rm Rk ( ( s /usr/lib/scons/SCons/Action.pyR� Q s N( R R R~ R� R R7 RB R� R� Rq R� ( ( ( s /usr/lib/scons/SCons/Action.pyRU � s # , R9 c B sk e Z d Z d � Z d � Z d � Z d � Z d � Z e e e e e d d � Z
d � Z d d � Z RS(
s! Class for lists of other actions.c C sD t | d � d � } t t | | � � | _ d | _ d | _ d S( Ns Action.ListActionc S s t | t � r | St | � S( N( R8 RP R6 ( R ( ( s /usr/lib/scons/SCons/Action.pyt list_of_actionsX s s $TARGETS( ( R R: R* R@ R| ( Rh t
actionlistR ( ( s /usr/lib/scons/SCons/Action.pyR� V s
c C s2 d j g | j D] } | j | | | � ^ q � S( Ns
( R R: Ro ( Rh Rl Rm Rk Rd ( ( s /usr/lib/scons/SCons/Action.pyRo b s c C s d j t t | j � � S( Ns
( R R* R" R: ( Rh ( ( s /usr/lib/scons/SCons/Action.pyR� e s c C s/ t j j g | j D] } | j | � ^ q � S( N( RG RV R� R: Rz ( Rh Rk Rd ( ( s /usr/lib/scons/SCons/Action.pyRz h s c C s2 d j g | j D] } | j | | | � ^ q � S( s| Return the signature contents of this action list.
Simple concatenation of the signatures of the elements.
R ( R R: Ru ( Rh Rl Rm Rk R ( ( s /usr/lib/scons/SCons/Action.pyRq l s c
C sg | r! | j � } | j � } n x? | j D]4 }
|
| | | | | | | | | � } | r+ | Sq+ Wd S( Ni ( R� R� R: ( Rh Rl Rm Rk R� R� R� R� R� R{ R] R� ( ( s /usr/lib/scons/SCons/Action.pyR s s c C s: g } x- | j D]" } | j | j | | | � � q W| S( N( R: t extendR� ( Rh Rl Rm Rk R R] ( ( s /usr/lib/scons/SCons/Action.pyR� s c C s` t j j � } x> | j D]3 } x* | j | | | | � D] } t | | <q8 Wq Wt | j � � S( N( RG RV t OrderedDictR: Rr R� t keys( Rh Rl Rm Rk R{ R R] R` ( ( s /usr/lib/scons/SCons/Action.pyRr � s
N(
R R R~ R� Ro R� Rz Rq R R7 R R� Rr ( ( ( s /usr/lib/scons/SCons/Action.pyR9 T s R c B sY e Z d Z d � Z d � Z d � Z d � Z d � Z d d � Z d � Z
d � Z RS(
sc A class for delaying calling an Action function with specific
(positional and keyword) arguments until the Action is actually
executed.
This class looks to the rest of the world like a normal Action object,
but what it's really doing is hanging on to the arguments until we
have a target, source and env to use for the expansion.
c C s | | _ | | _ | | _ d S( N( t parentRJ RK ( Rh R RJ RK ( ( s /usr/lib/scons/SCons/Action.pyR� � s c C s� | j j } y t | j j � } WnM t k
rq y t | j j j j � } Wqr t k
rm t | � } qr Xn Xt | � } | S( N( R t actfuncR" R/ R- R R R R ( Rh Rl Rm Rk R R. ( ( s /usr/lib/scons/SCons/Action.pyRu � s
c C s� t | � rR g } x- | D]% } | j | j | | | | � � q W| j j | � S| d k rb | St | � r� | j | d | | � S| j j | � S( Ns $__env__i ( RQ R Rs R t convertRD ( Rh R Rl Rm Rk R t elem( ( s /usr/lib/scons/SCons/Action.pyRs � s
# c C s, g | j D] } | j | | | | � ^ q
S( N( RJ Rs ( Rh Rl Rm Rk R ( ( s /usr/lib/scons/SCons/Action.pyt
subst_args� s c C sG i } x: | j j � D]) } | j | j | | | | � | | <q W| S( N( RK R Rs ( Rh Rl Rm Rk RK R� ( ( s /usr/lib/scons/SCons/Action.pyt subst_kw� s 'c C s= | j | | | � } | j | | | � } | j j | | � S( N( R" R# R R ( Rh Rl Rm Rk R{ RJ RK ( ( s /usr/lib/scons/SCons/Action.pyR � s c C s= | j | | | � } | j | | | � } | j j | | � S( N( R" R# R R
( Rh Rl Rm Rk RJ RK ( ( s /usr/lib/scons/SCons/Action.pyRB � s c C s | j j | j | j � S( N( R R
RJ RK ( Rh ( ( s /usr/lib/scons/SCons/Action.pyR� � s N( R R R~ R� Ru Rs R" R# R7 R RB R� ( ( ( s /usr/lib/scons/SCons/Action.pyR � s t
ActionFactoryc B s& e Z d Z d � d � Z d � Z RS( sf A factory class that will wrap up an arbitrary function
as an SCons-executable Action object.
The real heavy lifting here is done by the ActionCaller class.
We just collect the (positional and keyword) arguments that we're
called with and give them to the ActionCaller object we create,
so it can hang onto them until it needs them.
c C s | S( N( ( R ( ( s /usr/lib/scons/SCons/Action.pyR
� s c C s | | _ | | _ | | _ d S( N( R R
R ( Rh R R
R ( ( s /usr/lib/scons/SCons/Action.pyR� � s c O s+ t | | | � } t | d | j �} | S( NRB ( R R6 RB ( Rh RJ RK t acR� ( ( s /usr/lib/scons/SCons/Action.pyR � s ( R R R~ R� R ( ( ( s /usr/lib/scons/SCons/Action.pyR$ � s (7 R~ t __revision__t SCons.compatRG t disR� R t reR� R� t SCons.DebugR t SCons.Errorst SCons.Executort
SCons.UtilR� RV RD RQ R� R R� R� R� R R R R R R t compileR� R R# R R R? RN Rb RZ R6 RP R� R� R7 R� R� R� RR RT RX RU R9 R R$ ( ( ( s /usr/lib/scons/SCons/Action.pyt <module>M sd
& . 3 7� 4�Y){8F