B ›³ëbUã@s¶dZddlZddlZdddddddœZiax4e ¡D](\ZZe e¡Z xeD]Z e te <qLWq4W[ [ [d d iZdd„t ¡DƒZ d d e ¡dZ e e ej¡addddgZe dd e¡d¡Zdd„ZdddddddœZdd„Zeee ¡ƒdd„d d!Z d eeje ƒ¡Ze e¡Zd"d#gd$d#gd%d&gd'd&ggZx eD]Z e e d¡e d<q>Wd(d)„Z[[ [Gd*d+„d+ƒZe d,¡Ze d-¡Ze d.¡Z Gd/d0„d0ƒZ!Gd1d2„d2e!ƒZ"dS)3zSCons C Pre-Processor moduleéNz\s*(.+)z\s+(.+)Úz/\s+([_A-Za-z][_A-Za-z0-9_]*)($[^)]*$)?\s*(.*)z\s+([_A-Za-z][A-Za-z0-9_]*)))ÚifÚelif)ÚifdefÚifndef)ÚimportÚincludeÚinclude_next)ÚelseÚendif)Údefine)Úundefrzif(?!n?def)cCsg|]}t ||¡‘qS©)ÚoverrideÚget)Ú.0Úxrrú(lib/python3.7/site-packages/SCons/cpp.pyú Usrz ^\s*#\s*(ú|z)(.*)$z/\*.*\*/z/\*.*z//.*z\rz\s*(ú)cCsdd„|DƒS)NcSs$g|]}|dt d|d¡f‘qS)rré)ÚCPP_Expression_Cleaner_REÚsub)rÚtrrrrnsz+Cleanup_CPP_Expressions..r)ZtsrrrÚCleanup_CPP_Expressionsmsrz not z != z and z or )ú!z!=z&&z||ú?ú:cCst| d¡S)Nr)ÚCPP_to_Python_Ops_DictÚgroup)ÚmrrrÚ‚ór"cCst|ƒS)N)Úlen)Úarrrr"Šr#T)ÚkeyÚreversezdefined\s+(\w+)z"\1" in __dict__zdefined\s*$(\w+)$z(0x[0-9A-Fa-f]+)(?:L|UL)?z\1z(\d+)(?:L|UL)?cCs0t t|¡}xtD]\}}t |||¡}qW|S)zo Converts a C pre-processor expression into an equivalent Python expression that can be evaluated. )ÚCPP_to_Python_Ops_ExpressionrÚCPP_to_Python_Ops_SubÚCPP_to_Python_Eval_ListÚre)ÚsÚexprÚreplrrrÚ CPP_to_Python¢sr/c@s eZdZdZdd„Zdd„ZdS)ÚFunctionEvaluatorz6Handles delayed evaluation of a #define function call.cCs@||_t |¡|_y| d¡}Wntk r4YnX||_dS)z¶ Squirrels away the arguments and expansion value of a #define macro function for later evaluation when we must actually expand a value that uses it. z##N)ÚnameÚfunction_arg_separatorÚsplitÚargsÚAttributeErrorÚ expansion)Úselfr1r4r6rrrÚ__init__·szFunctionEvaluator.__init__csft|jƒt|ƒkr td|jƒ‚|j‰dd„tˆ|ƒDƒ}‡fdd„|jDƒ}d |¡}t|tƒ|ƒS)zo Evaluates the expansion of a #define macro function called with the specified values. z%Incorrect number of arguments to `%s'cSsi|]\}}||“qSrr)rÚkÚvrrrú Ñsz.FunctionEvaluator.__call__..cs g|]}|ˆkr|nt|ƒ‘qSr)Úrepr)rr,)r4rrrÒsz.FunctionEvaluator.__call__..z + ) r$r4Ú ValueErrorr1Úzipr6ÚjoinÚevalÚglobals)r7ÚvaluesZ localvarsÚpartsZ statementr)r4rÚ__call__Ås zFunctionEvaluator.__call__N)Ú__name__Ú __module__Ú__qualname__Ú__doc__r8rDrrrrr0´sr0z\\ ? z(\S+)$([^)]*)$z,\s*c@s(eZdZdZejdiddfdd„Zdd„Zd d „Zdd„Z dFdd„Z dd„Zdd„Zdd„Z dd„Zdd„Zdd„Zdd„Zdd„Zd d!„Zd"d#„Zd$d%„Zd&d'„ZdGd(d)„ZdHd*d+„Zd,d-„Zd.d/„Zd0d1„Zd2d3„Zd4d5„Zd6d7„Zd8d9„Zd:d;„Z dd?„Z"d@dA„Z#e#Z$dBdC„Z%dDdE„Z&d S)IÚPreProcessorz7The main workhorse class for handling C pre-processing.rréÿÿÿÿcCs€t|ƒ}|f|||fdœ|_| ¡|_|j|jd<|rB|j|_||_d|ji}x"t ¡D]}t |d|ƒ||<q\W||_dS)N)ú"ú<Ú__dict__Úscons_current_fileZdo_)ÚtupleÚ searchpathÚcopyÚ cpp_namespaceÚall_includeÚ do_includeÚdepthrNÚTableÚkeysÚgetattrÚ default_table)r7ZcurrentZcpppathÚdictÚallrUÚdÚoprrrr8és zPreProcessor.__init__cCs||_| |¡S)zU Pre-processes a file. This is the main public entry point. )Úcurrent_fileÚprocess_file)r7ÚfilerrrrDszPreProcessor.__call__cCs| | | |¡¡|¡S)zW Pre-processes a file. This is the main internal entry point. )Ú_process_tuplesÚtupleizeÚ read_file)r7r`rrrr_szPreProcessor.process_filecCs| | |¡¡S)zJ Pre-processes a file contents. Is used by tests )rarb)r7ÚcontentsrrrÚprocess_contents"szPreProcessor.process_contentsNcCs\g|_|j ¡|_||_||_| |¡x(|jrP|j d¡}|j|d|ƒq*W| |¡S)Nr) ÚstackrYrQÚdispatch_tabler^ÚtuplesÚinitialize_resultÚpopÚfinalize_result)r7rhr`rrrrra*s zPreProcessor._process_tuplescCs| | |¡¡S)a‰ Turns the contents of a file into a list of easily-processed tuples describing the CPP lines in the file. The first element of each tuple is the line's preprocessor directive (#if, #include, #define, etc., minus the initial '#'). The remaining elements are specific to the type of directive, as pulled apart by the regular expression. )Ú _match_tuplesÚ _parse_tuples)r7rdrrrrb9s zPreProcessor.tupleizecCst d|¡}t |¡}t|ƒS)Nr)Úline_continuationsrÚCPP_ExpressionÚfindallr)r7rdrhrrrrmEs zPreProcessor._parse_tuplescCsHg}x>|D]6}t|d |d¡}|r | |df| ¡¡q W|S)Nrr)rVÚmatchÚappendÚgroups)r7rhÚresultrr!rrrrlKs zPreProcessor._match_tuplescCs|j |j¡|j ¡|_dS)z† Pushes the current dispatch table on the stack and re-initializes the current dispatch table to the default. N)rfrrrgrYrQ)r7rrrÚsaveVszPreProcessor.savecCs*y|j ¡|_Wntk r$YnXdS)zf Pops the previous dispatch table off the stack and makes it the current one. N)rfrjrgÚ IndexError)r7rrrÚrestore^szPreProcessor.restorecCsdS)z Null method for when we explicitly want the action for a specific preprocessor directive to do nothing. Nr)r7rrrrÚ do_nothinghszPreProcessor.do_nothingcCs|d|_dS)Nr)r^)r7rrrrrNoszPreProcessor.scons_current_filec CsBtd |dd…¡ƒ}yt||jƒStttfk r<dSXdS)z× Evaluates a C preprocessor expression. This is done by converting it to a Python equivalent and eval()ing it in the C preprocessor namespace we use to track #define values. ú rNr)r/r?r@rRÚ NameErrorÚ TypeErrorÚSyntaxError)r7rrrrÚeval_expressionrs zPreProcessor.eval_expressioncCs|g|_dS)N)rt)r7Úfnamerrrri€szPreProcessor.initialize_resultcCs|jdd…S)Nr)rt)r7r~rrrrkƒszPreProcessor.finalize_resultcCsR|d}xD|j|dD]2}|tjkr,|}ntj ||¡}tj |¡r|SqWdS)zI Finds the #include file for a given preprocessor tuple. érN)rPÚosÚcurdirÚpathr?Úisfile)r7rr~r\ÚfrrrÚfind_include_file†s zPreProcessor.find_include_filec Cst|ƒ }| ¡SQRXdS)N)ÚopenÚread)r7r`r„rrrrc”s zPreProcessor.read_filecCs:|j}|jr|jdn|j}xdD]}||||<q"WdS)aX Causes the PreProcessor object to start processing #import, #include and #include_next lines. This method will be called when a #if, #ifdef, #ifndef or #elif evaluates True, or when we reach the #else in a #if, #ifdef, #ifndef or #elif block where a condition already evaluated False. rJ)rrr rr N)rgrfrY)r7rr\Úpr9rrrÚstart_handling_includesšs z$PreProcessor.start_handling_includescCs<|j}|j|d<|j|d<|j|d<|j|d<|j|d<dS)aN Causes the PreProcessor object to stop processing #import, #include and #include_next lines. This method will be called when a #if, #ifdef, #ifndef or #elif evaluates False, or when we reach the #else in a #if, #ifdef, #ifndef or #elif block where a condition already evaluated True. rrr rr N)rgrx)r7rr\rrrÚstop_handling_includes«s z#PreProcessor.stop_handling_includescCsP| ¡|j}|r0| ¡|j|d<|j|d<n| ¡|j|d<|j|d<dS)zf Common logic for evaluating the conditions on #if, #ifdef and #ifndef lines. rr N)rurgr‰rŠÚdo_elif)r7Z conditionr\rrrÚ_do_if_else_condition¿s z"PreProcessor._do_if_else_conditioncCs| |d|jk¡dS)z4 Default handling of a #ifdef line. rN)rŒrR)r7rrrrÚdo_ifdefÏszPreProcessor.do_ifdefcCs| |d|jk¡dS)z5 Default handling of a #ifndef line. rN)rŒrR)r7rrrrÚ do_ifndefÕszPreProcessor.do_ifndefcCs| | |¡¡dS)z1 Default handling of a #if line. N)rŒr})r7rrrrÚdo_ifÛszPreProcessor.do_ifcCs0|j}| |¡r,| ¡|j|d<|j|d<dS)z3 Default handling of a #elif line. rr N)rgr}r‰rŠ)r7rr\rrrr‹ás zPreProcessor.do_elifcCsdS)z3 Default handling of a #else line. Nr)r7rrrrÚdo_elseëszPreProcessor.do_elsecCs| ¡dS)z4 Default handling of a #endif line. N)rw)r7rrrrÚdo_endifñszPreProcessor.do_endifc Csˆ|\}}}}yt|ƒ}Wn<ttfk rTd|krP| |dd…¡|j|<dSYnX|rzt||dd…|ƒ}||j|<n ||j|<dS)z5 Default handling of a #define line. zdefined rNrrJ)Úintr{r=r}rRr0)r7rÚ_r1r4r6Z evaluatorrrrÚ do_define÷s zPreProcessor.do_definecCs*y|j|d=Wntk r$YnXdS)z4 Default handling of a #undef line. rN)rRÚKeyError)r7rrrrÚdo_undef szPreProcessor.do_undefcCsdS)z5 Default handling of a #import line. Nr)r7rrrrÚ do_importszPreProcessor.do_importcCs¸| |¡}|sdS| |¡}|r*||jkr.dS|j |¡|jdkrzd}x"|jD]}|ddkrP|d7}qPW||jkrzdSd|fg| | |¡¡d|jfg}||j|jdd…<dS)z6 Default handling of a #include line. NrJrrNr) Úresolve_includer…rtrrrUrhrbrcr^)r7rZinclude_fileZ current_depthZ new_tuplesrrrrTs" zPreProcessor.do_includecCsÆ|d ¡}xž|ddkrªy.|j|}xdD]}| d|›|¡}q,WWnVtk ržt |¡}|sjdS|j| d¡}t|ƒršt | d¡¡}||Ž}YnX|sdSqW|d|d|dd…fS) zøResolve a tuple-ized #include line. This handles recursive expansion of values without "" or <> surrounding the name until an initial " or < is found, to handle #include FILE where FILE is a #define somewhere else. rrz<"z<">ú\NrrJ) ÚstriprRÚreplacer•Ú function_nameÚsearchr Úcallabler2r3)r7rr,Úcr!r4rrrr˜Gs" zPreProcessor.resolve_includecCs|j | |¡¡dS)z N)rtrrr˜)r7rrrrrSiszPreProcessor.all_include)N)N)N)'rErFrGrHr€rr8rDr_rerarbrmrlrurwrxrNr}rirkr…rcr‰rŠrŒrrŽrr‹rr‘r”r–r—rTZdo_include_nextr˜rSrrrrrIæsD( +"rIc@seZdZdZdd„ZdS)ÚDumbPreProcessora“A preprocessor that ignores all #if/#elif/#else/#endif directives and just reports back *all* of the #include files (like the classic SCons scanner did). This is functionally equivalent to using a regular expression to find all of the #include lines, only slower. It exists mainly as an example of how the main PreProcessor class can be sub-classed to tailor its behavior. cOs<tj|f|ž|Ž|j}xdD]}|j||<||<qWdS)N)rrr rrr)rIr8rYrx)r7r4Úkwr\Úfuncrrrr8ys zDumbPreProcessor.__init__N)rErFrGrHr8rrrrr os r )#rHr€r+Zcpp_lines_dictrVÚitemsZop_listr-ÚcompileÚer]rrWÚlr?ÚMroZCPP_Expression_Cleaner_Listrrrr)ÚsortedÚlistÚmapÚescaper(r*r/r0rnrœr2rIr rrrrÚsp %