| 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 m Z d d l m Z m 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 e f d � � YZ e Z g d � Z d e j j f d
� � YZ d e j j f d � � YZ d
e j j f d � � YZ d e j f d � � YZ i d d 6d d 6Z d e j f d � � YZ d � Z d � Z d e f d � � YZ d e f d � � YZ! d e j j" f d � � YZ# d � Z$ d S( s� SCons.Builder
Builder object subsystem.
A Builder object is a callable that encapsulates information about how
to execute actions to create a target Node (file) from source Nodes
(files), and how to create those dependencies for tracking.
The main entry point here is the Builder() factory method. This provides
a procedural interface that creates the right underlying Builder object
based on the keyword arguments supplied and the types of the arguments.
The goal is for this external interface to be simple enough that the
vast majority of users can create new Builders as necessary to support
building new types of files in their configurations, without having to
dive any deeper into this subsystem.
The base class here is BuilderBase. This is a concrete base class which
does, in fact, represent the Builder objects that we (or users) create.
There is also a proxy that looks like a Builder:
CompositeBuilder
This proxies for a Builder with an action that is actually a
dictionary that knows how to map file suffixes to a specific
action. This is so that we can invoke different actions
(compilers, compile options) for different flavors of source
files.
Builders and their proxies have the following public interface methods
used by other modules:
__call__()
THE public interface. Calling a Builder object (with the
use of internal helper methods) sets up the target and source
dependencies, appropriate mapping to a specific action, and the
environment manipulation necessary for overridden construction
variable. This also takes care of warning about possible mistakes
in keyword arguments.
add_emitter()
Adds an emitter for a specific file suffix, used by some Tool
modules to specify that (for example) a yacc invocation on a .y
can create a .h *and* a .c file.
add_action()
Adds an action for a specific file suffix, heavily used by
Tool modules to add their specific action(s) for turning
a source file into an object file to the global static
and shared object file Builders.
There are the following methods for internal use within this module:
_execute()
The internal method that handles the heavily lifting when a
Builder is called. This is used so that the __call__() methods
can set up warning about possible mistakes in keyword-argument
overrides, and *then* execute all of the steps necessary so that
the warnings only occur once.
get_name()
Returns the Builder's name within a specific Environment,
primarily used to try to return helpful information in error
messages.
adjust_suffix()
get_prefix()
get_suffix()
get_src_suffix()
set_src_suffix()
Miscellaneous stuff for handling the prefix and suffix
manipulation we use in turning source file names into target
file names.
s6 src/engine/SCons/Builder.py 2013/03/03 09:48:35 garyoi����N( t logInstanceCreation( t
InternalErrort UserErrort _Nullc B s e Z RS( ( t __name__t
__module__( ( ( s /usr/lib/scons/SCons/Builder.pyR r s c C s� | r� g | D]# } | t | � | k r
| ^ q
} | r� t g | D] } t | � | f ^ qF � d } | t | � | t | � g Sn t j j | � S( Ni ( t lent maxt SConst Utilt splitext( t patht suffixest St matchsuft _ft suf( ( s /usr/lib/scons/SCons/Builder.pyt match_splitextw s 0/#t DictCmdGeneratorc B s8 e Z d Z d d d � Z d � Z d � Z d � Z RS( s� This is a callable class that can be used as a
command generator function. It holds on to a dictionary
mapping file suffixes to Actions. It uses that dictionary
to return the proper action based on the file suffix of
the source file.i c C s# t j j j | | � | | _ d S( N( R R t Selectort __init__t source_ext_match( t selft dictR ( ( s /usr/lib/scons/SCons/Builder.pyR � s c C s t | j � � S( N( t listt keys( R ( ( s /usr/lib/scons/SCons/Builder.pyt src_suffixes� s c C s | | | <d S( s1 Add a suffix-action pair to the mapping.
N( ( R t suffixt action( ( s /usr/lib/scons/SCons/Builder.pyt
add_action� s c C s� | s
g S| j r� | j � } d } x� t t | � D]e } t | | � d } | r� | | k r� t d t t t t | � � � | | | f � � n | } q5 Wn# t t | d � | j � � d } | s
t d t t t t | � � � t t t t | � � � f � � n y" t j
j j | | | | � } WnA t
k
rr}
t d |
j d |
j d |
j d f � � n X| d k r�t d t t t t | � � � t t t t | � � � | t t | j � � � f � � n | S( Ni s^ While building `%s' from `%s': Cannot build multiple sources with different extensions: %s, %si sG While building `%s': Cannot deduce file extension from source files: %ssA Ambiguous suffixes after environment substitution: %s == %s == %si s� While building `%s' from `%s': Don't know how to build from a source file with suffix `%s'. Expected a suffix in this list: %s.( R R t Nonet mapt strR R t reprR R R R t __call__t KeyErrort argsR ( R t targett sourcet envt
for_signatureR t extt srct my_extt rett e( ( s /usr/lib/scons/SCons/Builder.pyR" � s. .
#="2 UN( R R t __doc__R R R R R" ( ( ( s /usr/lib/scons/SCons/Builder.pyR s
t CallableSelectorc B s e Z d Z d � Z RS( sP A callable dictionary that will, in turn, call the value it
finds if it can.c C s= t j j j | | | � } t | � r9 | | | � } n | S( N( R R R R" t callable( R R' R& t value( ( s /usr/lib/scons/SCons/Builder.pyR" � s ( R R R. R" ( ( ( s /usr/lib/scons/SCons/Builder.pyR/ � s t DictEmitterc B s e Z d Z d � Z RS( sl A callable dictionary that maps file suffixes to emitters.
When called, it finds the right emitter in its dictionary for the
suffix of the first source file, and calls that emitter to get the
right lists of targets and sources to return. If there's no emitter
for the suffix in its dictionary, the original target and source are
returned.
c C sF t j j j | | | � } | r< | | | | � \ } } n | | f S( N( R R R R" ( R R% R& R' t emitter( ( s /usr/lib/scons/SCons/Builder.pyR" � s ( R R R. R" ( ( ( s /usr/lib/scons/SCons/Builder.pyR2 � s t ListEmitterc B s e Z d Z d � Z RS( sW A callable list of emitters that calls each in sequence,
returning the result.
c C s6 x) | j D] } | | | | � \ } } q
W| | f S( N( t data( R R% R& R' R- ( ( s /usr/lib/scons/SCons/Builder.pyR" � s ( R R R. R" ( ( ( s /usr/lib/scons/SCons/Builder.pyR4 � s R% t targetsR& t sourcest OverrideWarnerc B s e Z d Z d � Z d � Z RS( s' A class for warning about keyword arguments that we use as
overrides in a Builder call.
This class exists to handle the fact that a single Builder call
can actually invoke multiple builders. This class only emits the
warnings once, no matter how many Builders are invoked.
c C s- t j j | | � t | d � d | _ d S( Ns Builder.OverrideWarner( t collectionst UserDictR R R t already_warned( R R ( ( s /usr/lib/scons/SCons/Builder.pyR � s
c C ss | j r
d SxV | j � D]H } | t k r t | } d | | f } t j j t j j | � q q Wd | _ d S( Ns) Did you mean to use `%s' instead of `%s'?i ( R; R t misleading_keywordsR t Warningst warnt MisleadingKeywordsWarning( R t kt altt msg( ( s /usr/lib/scons/SCons/Builder.pyR> � s
( R R R. R R> ( ( ( s /usr/lib/scons/SCons/Builder.pyR8 � s c K s� d } d | k rT d | k r- t d � � n t j j | d i � | d <| d =n� d | k r� | j d d � } d | k r� | d =n t j j | d � r� t | d | � } t j j | i � | d <| j � | d <q� t j j | d � | d <n d | k r�| d } t j j
| � r`t j j | � } | sMt d | � � n t | � | d <q�t j j | � r�t
| � | d <q�t j j | � r�t | � | d <q�n t | � } | d k r�t | | � } n | S(
s A factory for builder objects.t generatorR s4 You must not specify both an action and a generator.R i t
src_suffixR3 sI Supplied emitter '%s' does not appear to refer to an Environment variableN( R R R t Actiont CommandGeneratorActiont getR t is_DictR R t is_Stringt get_environment_vart EmitterProxyR2 t is_ListR4 t BuilderBaset CompositeBuilder( t kwt compositeR R3 t vart result( ( s /usr/lib/scons/SCons/Builder.pyt Builder� s<
c C sW x�| D]�} | j r) t d | � � n | j � r | j d k r� | j | k r� | j j } | j | | | j � } | j | | | � } | | k r� d | | j | | | j � f } t j
j t j
j | � q� d | } t | � � n | j
r�| j | k r>d | j j | � | j | � | f } t | � � n | j � j � | k r�d | t t t | j � j � � � t t t | � � f } t | � � q�q�| j | k r�d | t t t | j � � t t t | � � f } t | � � q�q q W| j rSt | � d k rSt d t t t | � � t t t | � � f � � qSn d S(
s� Validate that the lists of target and source nodes are
legal for this builder and environment. Raise errors or
issue warnings as appropriate.
s= Multiple ways to build the same target were specified for: %sse Two different environments were specified for target %s,
but they appear to have the same action: %ssN Two environments with different actions were specified for the same target: %ssI Two different builders (%s and %s) were specified for the same target: %ssM Two different target lists have a target in common: %s (from %s and from %s)sT Multiple ways to build the same target were specified for: %s (from %s and from %s)i sK More than one source given for single-source builder: targets=%s sources=%sN( t side_effectR t has_explicit_builderR' R t builderR t get_contentst genstringR R= R> t DuplicateEnvironmentWarningt multit get_namet get_executort get_all_targetsR R R R7 t
single_sourceR ( RV R' t tlistt slistt tR t
t_contentst contentsRB ( ( s /usr/lib/scons/SCons/Builder.pyt _node_errors s4
"
(=4 RK c B s) e Z d Z d � Z d � Z d � Z RS( s This is a callable class that can act as a
Builder emitter. It holds on to a string that
is a key into an Environment dictionary, and will
look there at actual build time to see if it holds
a callable. If so, we will call that as the actual
emitter.c C s t j j | � | _ d S( N( R R t to_StringRQ ( R RQ ( ( s /usr/lib/scons/SCons/Builder.pyR H s c C s� | j } x, t j j | � r7 | | k r7 | | } q Wt | � r_ | | | | � \ } } n> t j j | � r� x) | D] } | | | | � \ } } qx Wn | | f S( N( RQ R R RI R0 RL ( R R% R& R' R3 R- ( ( s /usr/lib/scons/SCons/Builder.pyR" K s !
c C s t | j | j � S( N( t cmpRQ ( R t other( ( s /usr/lib/scons/SCons/Builder.pyt __cmp__\ s ( R R R. R R" Rh ( ( ( s /usr/lib/scons/SCons/Builder.pyRK A s RM c B s� e Z d Z e j j r' e j j Z n g Z d d d d d d d d d d d d d e
d d e d � Z d � Z
d � Z d � Z d d � Z e d � Z d d d
� Z i i d � Z d d e
d � Z d
� Z g d � Z d � Z g d � Z d � Z d � Z d � Z d � Z d � Z i d � Z d � Z e j e j j! d e � � d � Z" d � Z# e j e j j! d e# � � d � Z$ d � Z% RS( sd Base class for Builders, objects that create output
nodes (files) from input nodes (files).
t i i c K s� t | d � i | _ | | _ |
| _ t j j | � rI t | � } n | | _ t j j | � rs t | � } n | | _ | | _
d | k r� t j j t j j
d d � | j | d � | d =n d | k r� t j j t j j
d � | d =n | | _ | j | � | j | � | | _ | | _ | | _ | | _ | | _ | | _ |
rc|
| _ n i | _ | t k r�| | j d <n | | _ | d k r�g } n t j j | � s�| g } n | | _ d S( Ns Builder.BuilderBaset overridessC The "overrides" keyword to Builder() creation has been deprecated;
sF specify the items as keyword arguments to the Builder() call instead.t scannersw The "scanner" keyword to Builder() creation has been deprecated;
use: source_scanner or target_scanner as appropriate.t chdir( R t _memoR RZ R R RH R/ t prefixR' R^ R= R> t DeprecatedBuilderKeywordsWarningt updateRj t
set_suffixt set_src_suffixt
ensure_suffixt target_factoryt source_factoryt target_scannert source_scannerR3 t namet executor_kwt _nullt is_explicitR RL t src_builder( R R Rn R RD Rt Ru Rv Rw R3 RZ R' R^ Rx Rl R{ R| Rs Rj ( ( s /usr/lib/scons/SCons/Builder.pyR i sR
c C s t d � � d S( NsS Do not test for the Node.builder attribute directly; use Node.has_builder() instead( R ( R ( ( s /usr/lib/scons/SCons/Builder.pyt __nonzero__� s c C s� y; t | d j � � j | � } t | d j � � | SWnF t t t t f k
r� y | j SWq� t k
r t | j
� SXn Xd S( sB Attempts to get the name of the Builder.
Look at the BUILDERS variable of env, expecting it to be a
dictionary containing this Builder, and return the key of the
dictionary. If there's no key, then return a directly-configured
name (if there is one) or the name of the class (by default).t BUILDERSN( R t valuest indexR t AttributeErrorR# t TypeErrort
ValueErrorRx R t __class__( R R' R� ( ( s /usr/lib/scons/SCons/Builder.pyR[ � s
c C s t | j | j � S( N( Rf t __dict__( R Rg ( ( s /usr/lib/scons/SCons/Builder.pyRh � s c C s= | s | j } n | r* | j | � } n g } t | | � S( N( R' R R ( R R R' R ( ( s /usr/lib/scons/SCons/Builder.pyR
� s c C s� | s
g Sg } t j j | � s. | g } n xK | D]C } t j j | � rk t j j | | | | � } n | j | � q5 W| S( N( R R RL RI t
adjustixest append( R t filest preR Rs RR t f( ( s /usr/lib/scons/SCons/Builder.pyt _adjustixes� s
c s0 � j � � } � j � j � } � j � j � } � j | d | � } � j | | � } � j � | � } � j � | � } | d k ry | d j }
Wn; t
k
r� t d | d � � q<t k
r� g } q<X� � f d � } |
| | | � g } n9 � j | | | � j
� } � j | | d | d | �} � j r&g }
x7 | D]/ } | j � sR| j � � |
j | � qRqRW| } | } � j d | d | d � � \ } } x- |
D]% } | j � k r�| j d � q�q�W� j | | d | d | �} � j | | d | d | �} n | | f S( s< Create and return lists of target and source nodes.
i s3 Do not know how to create a target from source `%s'c s � j | � � S( N( R
( R
( R' R ( s /usr/lib/scons/SCons/Builder.pyt <lambda>� s R% R& R' N( t get_src_suffixt get_factoryRt Ru R� R t arg2nodest
get_prefixt
get_suffixt target_from_sourceR� R t
IndexErrorRs R3 t
is_derivedt builder_setR� RV ( R R' R% R& t src_sufRt Ru R` R� R t t_from_sR_ R
t new_targetsRa t
orig_tlistt
orig_slist( ( R' R s /usr/lib/scons/SCons/Builder.pyt
_create_nodes� sF
$
c C s | j r! | j | | | � } n | j r� t | � d k r� | d k r� g } | d k rp d g t | � } n xl t | | � D][ \ } } | d k r� | g } n | d k r� | g } n | j | j | | | | � � q� Wt j j
| � S| j � | j | | | � \ } }
t
| | | |
� d } d } | j r�y | d j d d � } Wn t t f k
roq�X| j |
� n | d k r<| j s�d }
t |
| j | p�| j � t t t | � � f � � n | j j | p�| j | |
� } | r<y t j j | � } Wn t k
r%q9X| j | |
� q<n | d k r�t j j | j | g | |
| � } | r�t j j | | � q�n xd | D]\ } | j j! � | _" | j# | � | j$ | � | j% |
� | j& | � | j' | j( � q�Wt j j
| � S( Ni i t creates+ Builder %s must have an action to build %s.() R| t src_builder_sourcesR^ R R t zipt extendt _executeR t Nodet NodeListR> R� Rd RZ R\ R� R� t add_sourcesR R R[ R' R R R t batch_keyt Executort GetBatchExecutorR# t add_batcht AddBatchExecutort fst getcwdt cwdR� t env_sett
add_sourcet set_executort set_explicitR{ ( R R' R% R& t overwarnRy RR t tgtR* R_ R` t executort keyt fmtRa ( ( s /usr/lib/scons/SCons/Builder.pyR� sb ' #
!
c K s� | t k r | j } n | j j � } | | d <| r� d | k r� | d d � } t j j | � sq | g } n t t | | � � } | d =n | j r� | j j � } | j | � q� | } n | j } | j
| � } | j | | | t | � | � S( NRl t srcdirc S sM d d l } t j j | � rI | j j | � rI | j j | | � } n | S( Ni����( t os.pathR R RI R t isabst join( R� R� t os( ( s /usr/lib/scons/SCons/Builder.pyt prependDirIfRelativeg s %(
Rz Ry t copyR R RL R R Rj Rp t OverrideR� R8 ( R R' R% R& Rl RO t ekwR� t env_kw( ( s /usr/lib/scons/SCons/Builder.pyR" \ s$
c C s" | r | d d k r d | S| S( Ni t .t _t $( R� R� R� ( ( R t suff( ( s /usr/lib/scons/SCons/Builder.pyt
adjust_suffixz s c C s4 | j } t | � r' | | | � } n | j | � S( N( Rn R0 t subst( R R' R7 Rn ( ( s /usr/lib/scons/SCons/Builder.pyR� s c C s+ t | � s | j | � } n | | _ d S( N( R0 R� R ( R R ( ( s /usr/lib/scons/SCons/Builder.pyRq � s c C s4 | j } t | � r' | | | � } n | j | � S( N( R R0 R� ( R R' R7 R ( ( s /usr/lib/scons/SCons/Builder.pyR� � s c C sh | s g } n t j j | � s- | g } n g | D]' } t | � rL | pX | j | � ^ q4 | _ d S( N( R R RL R0 R� RD ( R RD R ( ( s /usr/lib/scons/SCons/Builder.pyRr � s
c C s! | j | � } | s d S| d S( s5 Get the first src_suffix in the list of src_suffixes.Ri i ( R ( R R' R, ( ( s /usr/lib/scons/SCons/Builder.pyR� � s c C s | | j | <d S( s? Add a suffix-emitter mapping to this Builder.
This assumes that emitter has been initialized with an
appropriate dictionary type, and will throw a TypeError if
not, so the caller is responsible for knowing that this is an
appropriate method to call for the Builder in question.
N( R3 ( R R R3 ( ( s /usr/lib/scons/SCons/Builder.pyt add_emitter� s c C s i | _ | j j | � d S( s�
Add a new Builder to the list of src_builders.
This requires wiping out cached values so that the computed
lists of source suffixes get re-calculated.
N( Rm R| R� ( R RV ( ( s /usr/lib/scons/SCons/Builder.pyt add_src_builder� s c C sH i } x; | j | � D]* } x! | j | � D] } | | | <q, Wq W| S( su
Returns a dictionary mapping all of the source suffixes of all
src_builders of this Builder to the underlying Builder that
should be called first.
This dictionary is used for each target specified, so we save a
lot of extra computation by memoizing it for each construction
environment.
Note that this is re-computed each time, not cached, because there
might be changes to one of our source Builders (or one of their
source Builders, and so on, and so on...) that we can't "see."
The underlying methods we call cache their computed values,
though, so we hope repeatedly aggregating them into a dictionary
like this won't be too big a hit. We may need to look for a
better way to do this if performance data show this has turned
into a significant bottleneck.
( t get_src_buildersR ( R R' t sdictt bldR ( ( s /usr/lib/scons/SCons/Builder.pyt
_get_sdict� s
c C s� | j | � } | j | � } t t t t | � � � } | | d � } g } x;t j j | � D]'} t j j | � r� | | j
| � � }
|
r� d | k r� | j | � } | j | d | � d } q� n | | j � }
|
r{y | |
} Wn t k
r| j | � q�X| j | d | g | � }
t |
� d k rkg |
D] } | | j � rG| ^ qG}
n | j |
� qa | j | � qa W| j | j � } | j | | � S( Nc S sC g | D] } | | ^ q } x | D] } | | k r% | Sq% Wd S( N( R ( Rx R t lengthst lt
node_suffixesR ( ( s /usr/lib/scons/SCons/Builder.pyt match_src_suffix� s
R� i i ( R� R R t setR R R R t flattenRI R� R� R� R Rx R# R� R� R� R� Ru R� ( R R' R& R� R� R R� R� RR t st match_suffixR� R� R_ Ra Ru ( ( s /usr/lib/scons/SCons/Builder.pyR� � s0
+c C s
t | � S( N( t id( R R' ( ( s /usr/lib/scons/SCons/Builder.pyt _get_src_builders_key� s R� c C s� t | � } y | j d } Wn$ t k
rC i } | | j d <n! Xy | | SWn t k
rc n Xg } x\ | j D]Q } t j j | � r� y | d | } Wq� t k
r� qt q� Xn | j | � qt W| | | <| S( s�
Returns the list of source Builders for this Builder.
This exists mainly to look up Builders referenced as
strings in the 'BUILDER' variable of the construction
environment and cache the result.
R� R~ ( R� Rm R# R| R R RI R� ( R R' t memo_keyt memo_dictt buildersR� ( ( s /usr/lib/scons/SCons/Builder.pyR� � s(
c C s
t | � S( N( R� ( R R' ( ( s /usr/lib/scons/SCons/Builder.pyt _subst_src_suffixes_key s t subst_src_suffixesc C s� t | � } y | j d } Wn$ t k
rC i } | | j d <n! Xy | | SWn t k
rc n Xg | j D] } | j | � ^ qn } | | | <| S( s�
The suffix list may contain construction variable expansions,
so we have to evaluate the individual strings. To avoid doing
this over and over, we memoize the results for each construction
environment.
R� ( R� Rm R# RD R� ( R R' R� R� t xR ( ( s /usr/lib/scons/SCons/Builder.pyR� ! s
%
c C s� i } | j | � } x | D] } d | | <q WxW | j | � D]F } x= | j | � D], } | | k rV d | | <| j | � qV qV Wq@ W| S( s+
Returns the list of source suffixes for all src_builders of this
Builder.
This is essentially a recursive descent of the src_builder "tree."
(This value isn't cached because there may be changes in a
src_builder many levels deep that we can't see.)
i ( R� R� R R� ( R R' R� R R� RV ( ( s /usr/lib/scons/SCons/Builder.pyR 7 s
N(& R R R. R t Memoizet use_memoizert Memoized_Metaclasst
__metaclass__t memoizer_countersR Rz t FalseR R} R[ Rh R
R� R� R� R" R� R� Rq R� Rr R� R� R� R� R� R� R� t CountDictR� R� R� R ( ( ( s /usr/lib/scons/SCons/Builder.pyRM _ s\ 4
?C
+ RN c B s2 e Z d Z d � Z e j j d � Z d � Z RS( s� A Builder Proxy whose main purpose is to always have
a DictCmdGenerator as its action, and to provide access
to the DictCmdGenerator's add_action() method.
c C s9 t | d � t j j j | | � | | _ | | _ d S( Ns Builder.CompositeBuilder( R R R t ProxyR t cmdgenRV ( R RV R� ( ( s /usr/lib/scons/SCons/Builder.pyR Q s
R" c C s- | j j | | � | j | j j � � d S( N( R� R Rr R ( R R R ( ( s /usr/lib/scons/SCons/Builder.pyR [ s ( R R R. R R R t DelegateR" R ( ( ( s /usr/lib/scons/SCons/Builder.pyRN K s c C s( t | t � p' t | t � p' t | � S( s� "Returns True iff the specified obj is one of our Builder classes.
The test is complicated a bit by the fact that CompositeBuilder
is a proxy, not a subclass of BuilderBase.
( t
isinstanceRM RN R0 ( t obj( ( s /usr/lib/scons/SCons/Builder.pyt is_a_Builder_ s (% R. t __revision__R9 t SCons.ActionR t SCons.DebugR t SCons.ErrorsR R t SCons.Executort
SCons.Memoizet
SCons.Nodet
SCons.Node.FSt
SCons.Utilt SCons.Warningst objectR Rz R R R R R/ R2 t UserListR4 R< R: R8 RS Rd RK RM R� RN R� ( ( ( s /usr/lib/scons/SCons/Builder.pyt <module>L s: 2
* ' � �