!^c@sdZddlZddlZddlZddlmZmZmZdejfdYZ dZ dZ dZ dZ eZd d gZejrgZnd Zd Zi d d 6d d6dd6dd6dd6dd6dd6dd6dd6dd6dd 6Zejd!ejejBZejd"Zejd#Zejd$ejZejd%ejZejd&ejejBZged'd(D]\Z Z!d)e e!f^qZ"i d d*6d+d,6d-d.6d/d06d1d26d3d46d5d66d7d86d9d:6d;d<6Z#d=Z$d>Z%d?Z&d@Z'dAZ(e$e'e&e%gZ)dBdCdDdEgZ*ejdj+gee)e*D]\Z,Z-dFe,e-f^qVej.Z/d,Z0d=Z1dGZ2d@Z3dHZ4iZ5dIdJdKdLdMdNdOdPgZ6x;e7e6D]-\Z8Z9xe9j:D]Z;e8e5e;dTZ?dUZ@dVZAgdWZBdXZCdYZDejdZZEd[ZFd\ZGd]ZHd^ZId_ZJd`eKfdaYZLdbZMdS(cs C/C++ preprocessor for finding dependencies Reasons for using the Waf preprocessor by default #. Some c/c++ extensions (Qt) require a custom preprocessor for obtaining the dependencies (.moc files) #. Not all compilers provide .d files for obtaining the dependencies (portability) #. A naive file scanner will not catch the constructs such as "#include foo()" #. A naive file scanner will catch unnecessary dependencies (change an unused header -> recompile everything) Regarding the speed concerns: * the preprocessing is performed only when files must be compiled * the macros are evaluated only for #if/#elif/#include * system headers are not scanned by default Now if you do not want the Waf preprocessor, the tool +gccdeps* uses the .d files produced during the compilation to track the dependencies (useful when used with the boost libraries). It only works with gcc >= 4.4 though. A dumb preprocessor is also available in the tool *c_dumbpreproc* iN(tLogstUtilstErrorst PreprocErrorcBseZRS((t__name__t __module__(((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyR sit-is/usr/local/includes /usr/includeit!tnottnot_eqs&&tands&=tand_eqs||tors|=tor_eqt^txors^=txor_eqt&tbitandt|tbitort~tcomplsc^[ ]*(?:#|%:)[ ]*(ifdef|ifndef|if|else|elif|endif|include|import|define|undef|pragma)[ ]*(.*) *$s ^[a-zA-Z_]\w*s^[a-zA-Z_][a-zA-Z0-9_]*[(]s ^\s*once\s*s\\ * s7//.*?$|/\*.*?\*/|\'(?:\\.|[^\\\'])*\'|"(?:\\.|[^\\"])*"s =-/!'()<>s #~\|^[]{}s??t0itaitbi tti tni tfi tvi tri\s\i't'titOtTtstcs$0[xX](?P[a-fA-F0-9]+)(?P[uUlL]*)|L*?'(?P(\\.|[^\\'])+)'|(?P\d+)[Ee](?P[+-]*?\d+)(?P[fFlL]*)|(?P\d*\.\d+)([Ee](?P[+-]*?\d+))?(?P[fFlL]*)|(?P\d+\.\d*)([Ee](?P[+-]*?\d+))?(?P[fFlL]*)|(?P0*)(?P\d+)(?P[uUlL]*)sL?"([^"\\]|\\.)*"s [a-zA-Z_]\w*s%:%:|<<=|>>=|\.\.\.|<<|<%|<:|<=|>>|>=|\+\+|\+=|--|->|-=|\*=|/=|%:|%=|%>|==|&&|&=|\|\||\|=|\^=|:>|!=|##|[\(\)\{\}\[\]<>\?\|\^\*\+&=:!#;,%/\-\?\~\.]s (?P<%s>%s)tucCs$|j}|ddkr dS|S(sCReplace function used with :py:attr:`waflib.Tools.c_preproc.re_cpp`it/t (tgroup(tmR#((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pytrepls s* / %s+ -s<< >>s < <= >= >s== !=s& | ^s&& ||t,cCsyd|}Wntk r-t|}nXyd|}Wntk r[t|}nX|}|dkr{||}nV|dkr||}n=|dkr||}n$|dkr||}n |dkr||}n|dkr||A}n|dkrt||k}n|d ks1|d kr>||B}n|d ksV|d krkt|pb|}nf|d ks|dkr||@}nA|dks|dkrt|o|}n|dks|dkrt||k}n|dks|dkrt||A}n|dkr6t||k}n|dkrWt||k}nz|dkrxt||k}nY|dkrt||k}n8|dkr||>}n|dkr||?}nd}|S(s Apply arithmetic rules to compute a result :param val1: input parameter :type val1: int or string :param val2: input parameter :type val2: int or string :param val_op: C operator in *+*, */*, *-*, etc :type val_op: string :rtype: int it%t+Rt*R&Rs==RRs||R RRs&&R s!=R Rs<=ts>=s<>(t TypeErrortint(tval_1tval_2tval_opRRtdR$((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyt reduce_numssb                         cCs!|stdn|d\}}|tkr|dkrd}d}x|t|kr||\}}|tkr|dkr|d8}|dkrPqq|dkr|d7}qn|d7}qLWtd|t|d|!\}}|||dfS|dkr"t|dS|dkrZt|d\}}td |d |fS|d krt|d\}}tt| |fS|d krt|d\}}t||fStd |nD|tkr||dfS|tkr d|dfStd|dS(s- Try to obtain a number from a list of tokens. The token types are defined in :py:attr:`waflib.Tools.ccroot.tok_types`. :param lst: list of preprocessor tokens :type lst: list of tuple (tokentype, value) :return: a pair containing the number and the rest of the list :rtype: tuple(value, list) sempty list for get_numit(it)srparen expected %rR-Rs-1R.RRsInvalid op token %r for get_numsInvalid token %r for get_numN( RtOPtlentget_termtget_numR7R2tNUMtIDENT(tlsttpRt count_parR tnumt_((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyR=sJ              c Css|stdnt|\}}|s7|gfS|d\}}|tkr_|dkrmt|dS|dkrZd}d}x|t|kr||\}}|tkr |dkr|d8}q |dkr|d7}q |dkr |dkrPqq n|d7}qWtd |t|rEt|d|!St||dSq_t|d\}}|st|||}tt|fg|S|d\}}|tkrtd |nt|t|kr t|||}tt|fg|St|d\} }t|| |} tt|f||ft| fg|Sntd |d S( s Evaluate an expression recursively, for example:: 1+1+1 -> 2+1 -> 3 :param lst: list of tokens :type lst: list of tuple(token, value) :return: the value and the remaining tokens :rtype: value, list sempty list for get_termiR+it?R9R8t:srparen expected %rsop expected %rscannot reduce %rN( RR=R:R<R;R2R7R>tprec( R@RCRARRBR tnum2tp2tv2tnum3((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyR<sR               ,cCst|\}}t|fS(s Take a list of tokens and output true or false for #if/#elif conditions. :param lst: a list of tokens :type lst: list of tuple(token, value) :return: a token :rtype: tuple(NUM, int) (R<R>(R@RC((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyt reduce_eval\s cCs2g|D]\}}t|^q}dj|S(s Merge a list of tokens into a string :param lst: a list of tokens :type lst: list of tuple(token, value) :rtype: string t(tstrtjoin(R@RIRJ((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyt stringizehs%cCsd}|dtkr/|dtkr/t}nb|dtkrh|dtks_|dtkrht}n)|dtkr|dtkrt}n|std||fn||d|dfS(s Token pasting works between identifiers, particular operators, and identifiers and numbers:: a ## b -> ab > ## = -> >= a ## 2 -> a2 :param t1: token :type t1: tuple(type, value) :param t2: token :type t2: tuple(type, value) is*tokens do not make a valid paste %r and %riN(tNoneR:R?R>R(tt1tt2tp1((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyt paste_tokensss   0   cCsd}x|t|kr||\}}|tkr(|dkr(||=|t|kr||\}}|tkr||krtdf||R:Rt isinstanceRNt extract_macrotlistt reduce_tokenstinserttappendtSTRRPRUtextendtpoptrange(R@tdefstbanR RARRIRJRRt macro_deftto_addtaccuttmptargst one_paramt count_parent arg_tabletjttoksRRtva_tokststtpttxtp3tv3tp4tv4((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyR\s                  F  00       #cCst||g|s%tdn|ri|d\}}|tkri||kritd|qint|\}}t|dkS(s Reduce the tokens by :py:func:`waflib.Tools.c_preproc.reduce_tokens` and try to return a 0/1 result by :py:func:`waflib.Tools.c_preproc.reduce_eval`. :param lst: list of tokens :type lst: list of tuple(token, value) :param defs: macro definitions :type defs: dict :rtype: int smissing tokens to evaluateismissing macro %r(R\RR?RLR2(R@RcRAR((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyt eval_macro<s c Cs>t|}tj|r|d\}}|d\}}|tkrVtdnd}d}i}d}xh|d7}||\}}|dkr|tkr|||<|d7}|}q|tkr|dkrPqtdqq|tkrC|tkr|dkr|}q|tkr4|dkr4Pqtdqq|dkr|tkrx|||<|d7}|}q|tkr|d krtd qtd qq|d krtd qqtd qqW||||dgfS|d\}}t|dkr'|g|dgfS|gdggfSdS(s> Process a macro definition of the form:: #define f(x, y) x * y into a function or a simple macro without arguments :param txt: expression to exact a macro definition from :type txt: string :return: a tuple containing the name, the list of arguments and the replacement :rtype: tuple(string, [list, list]) iis expected (R8R9sunexpected token (3)R+scomma or ... expecteds...snot implemented (1)scomma or ... expected (2)snot implemented (2)sunexpected elseR"RMN(R"RM(ttokenizetre_funtsearchR:RR?R;( ttxtRRAtnameRR tpindextparamstprev((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyRZRsV                s^\s*(<(?:.*)>|"(?:.*)")cCstj|}|r9|jd}|d|dd!fSt|}t||dg|sqtd|nt|dkr|ddtkrd|ddfSnP|dddkr|dddkrdt|j dj df}|Std|d S( s Process a line in the form:: #include foo :param txt: include line to process :type txt: string :param defs: macro definitions :type defs: dict :return: the file name :rtype: string iiit waf_includescould not parse include %rt"R/R0N( t re_includeRzR(RxR\RR;R_RPtlstriptrstrip(R{RcR)Rntret((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pytextract_includes  ($cCsM|stdn|ddkr/t|S|d}|dkrt|dkr{|dtjkr{t|dd St|dd S|jr|d krt|dkrdSxdD]Q}t||kr|dd|!jrd|t|dd|!d fSqWn0y t|SWn!tk rHtd |nXd S(sy Parse a c character :param txt: character to parse :type txt: string :return: a character literal :rtype: string sattempted to parse a null charis\iRriiiiRiscould not parse char literal %rN(iii( RtordR;tstringt hexdigitsR2tisdigittchr_esctKeyError(R{R$R ((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyt parse_chars&    %  ))  cCs t|S(s Convert a string into a list of tokens (shlex.split does not apply to c/c++/d) :param s: input to tokenize :type s: string :return: a list of tokens :rtype: list of tuple(token, value) (ttokenize_private(R#((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyRxs cCsg}xtj|D]}|j}xtD]}||}|r,|tkr|tkret}q|jdkrd}t}q|jdkrd}t}qn|tkrO|drt |d}q|drt |dd}q|d r|d }q|d }|r4t |}q|d pI|d }nU|tkr|d krpd}q|dkrd}qn|t kr|dd!}n|j ||fPq,q,WqW|S(Nttrueitfalseitoctithexitn0tchartn2tn4s%:RWs%:%:s##i( t re_clexertfinditerR(t tok_typesR?t g_optransR:tlowerR>R2RR_R^(R#RtmatchR)R|R((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyRsH                    cCsg}x|D]|}|r |jd}|dkrD|j|q|dkrv|jd|| ||dfqtd|q q W|S(Nt=iis%s %sisInvalid define expression %r(tfindR^t ValueError(R@Rtytpos((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pytformat_definess   &tc_parsercBsbeZdZd d dZdZdd dZdZdZdZ dZ d Z RS( s~ Used by :py:func:`waflib.Tools.c_preproc.scan` to parse c/h files. Note that by default, only project headers are parsed. cCsg|_|dkr!i|_nt||_g|_d|_g|_|pTg|_g|_g|_ d|_ t |_ t |_ dS(NiRM(tlinesRQRctdicttstatet count_filestcurrentnode_stackt nodepathstnodestnamestcurfiletsett ban_includestlisted(tselfRtdefines((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyt__init__"s           cCsy|jj}Wn*tk r<tjt}|j_nX||f}y ||SWntk r|j|}|rt|ddrd}q|j |jj r|jj j |j|jj }|rt|ddrd}qqn|||<|SXdS(s Find a file from the input directory :param node: directory :type node: :py:class:`waflib.Node.Node` :param filename: header to find :type filename: string :return: the node if found, or None :rtype: :py:class:`waflib.Node.Node` tchildrenN(tctxtpreproc_cache_nodetAttributeErrorRt lru_cachetFILE_CACHE_SIZERt find_resourcetgetattrRQt is_child_oftbldnodetsrcnodet search_nodet path_from(RtnodetfilenametcachetkeyRRh((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pytcached_find_resourceAs$      $ RcCs_|jdr#|jj|dS||_d}|dkr|jrxOt|jD]"}|j||}|rWPqWqWWq|j|jd|}n|sx0|j D]"}|j||}|rPqqWn|j }|r/||j kr/||kr|j ||j j|n|j|n,||kr[|j ||jj|n|S(s Try to obtain a node from the filename based from the include paths. Will add the node found to :py:attr:`waflib.Tools.c_preproc.c_parser.nodes` or the file name to :py:attr:`waflib.Tools.c_preproc.c_parser.names` if no corresponding file is found. Called by :py:attr:`waflib.Tools.c_preproc.c_parser.start`. :param filename: header to find :type filename: string :return: the node if found :rtype: :py:class:`waflib.Node.Node` s.mocRiN(tendswithRR^RQRt MSVC_VERSIONtreversedRRRRRtaddRtaddlines(RRtkindtenvtfoundRR((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyttryfind`s6           cCsu|j}trDx/tD]$\}}|j|j|}qWntjd|}tjt|}t j |S(sW Filter the comments from a c/h file, and return the preprocessor lines. The regexps :py:attr:`waflib.Tools.c_preproc.re_cpp`, :py:attr:`waflib.Tools.c_preproc.re_nl` and :py:attr:`waflib.Tools.c_preproc.re_lines` are used internally. :return: the preprocessor directives as a list of (keyword, line) :rtype: a list of string pairs RM( treadt use_trigraphsttrig_deftsplitROtre_nltsubtre_cppR*tre_linestfindall(RRtcodeRR((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pytfilter_commentss cCsy|jj}Wn*tk r<tjt}|j_nXy ||SWnFtk r|j|||<}|jt df|j |SXdS(NRM( Rtpreproc_cache_linesRRRtLINE_CACHE_SIZERRR^tPOPFILEtreverse(RRRR((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyt parse_liness    cCs|jj|j|jd7_|jtkr@tdntjr\tjd|ny|j |}Wn\t k rtd|nLt k rtjdkrtj d|t jqnX|jj|dS(s Add the lines from a header in the list of preprocessor lines to parse :param node: header :type node: :py:class:`waflib.Node.Node` isrecursion limit exceededspreproc: reading file %rscould not read the file %risparsing %r failed %sN(RR^tparentRtrecursion_limitRRtverbosetdebugRtEnvironmentErrort Exceptionterrort tracebackt format_excRR`(RRR((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyRs    c Csitjd|j|jj||_|j||jrt|j}|j|j j g|D]}d|f^qdnx|j rd|j j \}}|t kr|j d8_ |jj qnyT|j}|d dkr|jtn|dkr|j n|ddkrKt|jksBt|jkrKwqKn|dkrtt||j}|rt|d R:R?R_tCHARRt exp_typesROR|tparttMRRRRRR*RGtopst enumerateRrtsymsRR%R7R=R<RLRPRUR\RwRZRRRRxRRtobjectRR (((s9/git_repos/PolyLV2/poly_mclk_in/waflib/Tools/c_preproc.pyts$    2L J  C 6 E   E #  )