source: waflib/Tools/qt4.py @ 904702d

feature/autosinkfeature/cnnfeature/cnn_orgfeature/constantqfeature/crepefeature/crepe_orgfeature/pitchshiftfeature/pydocstringsfeature/timestretchfix/ffmpeg5pitchshiftsamplertimestretchyinfft+
Last change on this file since 904702d was 904702d, checked in by Paul Brossier <piem@piem.org>, 9 years ago

waf, waflib: update to 1.8.7
  • Property mode set to 100644
File size: 13.8 KB
Line 
1#! /usr/bin/env python
2# encoding: utf-8
3# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file
4
5try:
6        from xml.sax import make_parser
7        from xml.sax.handler import ContentHandler
8except ImportError:
9        has_xml=False
10        ContentHandler=object
11else:
12        has_xml=True
13import os,sys
14from waflib.Tools import cxx
15from waflib import Task,Utils,Options,Errors,Context
16from waflib.TaskGen import feature,after_method,extension
17from waflib.Configure import conf
18from waflib import Logs
19MOC_H=['.h','.hpp','.hxx','.hh']
20EXT_RCC=['.qrc']
21EXT_UI=['.ui']
22EXT_QT4=['.cpp','.cc','.cxx','.C']
23QT4_LIBS="QtCore QtGui QtUiTools QtNetwork QtOpenGL QtSql QtSvg QtTest QtXml QtXmlPatterns QtWebKit Qt3Support QtHelp QtScript QtDeclarative QtDesigner"
24class qxx(Task.classes['cxx']):
25        def __init__(self,*k,**kw):
26                Task.Task.__init__(self,*k,**kw)
27                self.moc_done=0
28        def runnable_status(self):
29                if self.moc_done:
30                        return Task.Task.runnable_status(self)
31                else:
32                        for t in self.run_after:
33                                if not t.hasrun:
34                                        return Task.ASK_LATER
35                        self.add_moc_tasks()
36                        return Task.Task.runnable_status(self)
37        def create_moc_task(self,h_node,m_node):
38                try:
39                        moc_cache=self.generator.bld.moc_cache
40                except AttributeError:
41                        moc_cache=self.generator.bld.moc_cache={}
42                try:
43                        return moc_cache[h_node]
44                except KeyError:
45                        tsk=moc_cache[h_node]=Task.classes['moc'](env=self.env,generator=self.generator)
46                        tsk.set_inputs(h_node)
47                        tsk.set_outputs(m_node)
48                        if self.generator:
49                                self.generator.tasks.append(tsk)
50                        gen=self.generator.bld.producer
51                        gen.outstanding.insert(0,tsk)
52                        gen.total+=1
53                        return tsk
54        def moc_h_ext(self):
55                try:
56                        ext=Options.options.qt_header_ext.split()
57                except AttributeError:
58                        pass
59                if not ext:
60                        ext=MOC_H
61                return ext
62        def add_moc_tasks(self):
63                node=self.inputs[0]
64                bld=self.generator.bld
65                try:
66                        self.signature()
67                except KeyError:
68                        pass
69                else:
70                        delattr(self,'cache_sig')
71                include_nodes=[node.parent]+self.generator.includes_nodes
72                moctasks=[]
73                mocfiles=set([])
74                for d in bld.raw_deps.get(self.uid(),[]):
75                        if not d.endswith('.moc'):
76                                continue
77                        if d in mocfiles:
78                                continue
79                        mocfiles.add(d)
80                        h_node=None
81                        base2=d[:-4]
82                        for x in include_nodes:
83                                for e in self.moc_h_ext():
84                                        h_node=x.find_node(base2+e)
85                                        if h_node:
86                                                break
87                                if h_node:
88                                        m_node=h_node.change_ext('.moc')
89                                        break
90                        else:
91                                for k in EXT_QT4:
92                                        if base2.endswith(k):
93                                                for x in include_nodes:
94                                                        h_node=x.find_node(base2)
95                                                        if h_node:
96                                                                break
97                                                if h_node:
98                                                        m_node=h_node.change_ext(k+'.moc')
99                                                        break
100                        if not h_node:
101                                raise Errors.WafError('No source found for %r which is a moc file'%d)
102                        task=self.create_moc_task(h_node,m_node)
103                        moctasks.append(task)
104                self.run_after.update(set(moctasks))
105                self.moc_done=1
106class trans_update(Task.Task):
107        run_str='${QT_LUPDATE} ${SRC} -ts ${TGT}'
108        color='BLUE'
109Task.update_outputs(trans_update)
110class XMLHandler(ContentHandler):
111        def __init__(self):
112                self.buf=[]
113                self.files=[]
114        def startElement(self,name,attrs):
115                if name=='file':
116                        self.buf=[]
117        def endElement(self,name):
118                if name=='file':
119                        self.files.append(str(''.join(self.buf)))
120        def characters(self,cars):
121                self.buf.append(cars)
122@extension(*EXT_RCC)
123def create_rcc_task(self,node):
124        rcnode=node.change_ext('_rc.cpp')
125        self.create_task('rcc',node,rcnode)
126        cpptask=self.create_task('cxx',rcnode,rcnode.change_ext('.o'))
127        try:
128                self.compiled_tasks.append(cpptask)
129        except AttributeError:
130                self.compiled_tasks=[cpptask]
131        return cpptask
132@extension(*EXT_UI)
133def create_uic_task(self,node):
134        uictask=self.create_task('ui4',node)
135        uictask.outputs=[self.path.find_or_declare(self.env['ui_PATTERN']%node.name[:-3])]
136@extension('.ts')
137def add_lang(self,node):
138        self.lang=self.to_list(getattr(self,'lang',[]))+[node]
139@feature('qt4')
140@after_method('apply_link')
141def apply_qt4(self):
142        if getattr(self,'lang',None):
143                qmtasks=[]
144                for x in self.to_list(self.lang):
145                        if isinstance(x,str):
146                                x=self.path.find_resource(x+'.ts')
147                        qmtasks.append(self.create_task('ts2qm',x,x.change_ext('.qm')))
148                if getattr(self,'update',None)and Options.options.trans_qt4:
149                        cxxnodes=[a.inputs[0]for a in self.compiled_tasks]+[a.inputs[0]for a in self.tasks if getattr(a,'inputs',None)and a.inputs[0].name.endswith('.ui')]
150                        for x in qmtasks:
151                                self.create_task('trans_update',cxxnodes,x.inputs)
152                if getattr(self,'langname',None):
153                        qmnodes=[x.outputs[0]for x in qmtasks]
154                        rcnode=self.langname
155                        if isinstance(rcnode,str):
156                                rcnode=self.path.find_or_declare(rcnode+'.qrc')
157                        t=self.create_task('qm2rcc',qmnodes,rcnode)
158                        k=create_rcc_task(self,t.outputs[0])
159                        self.link_task.inputs.append(k.outputs[0])
160        lst=[]
161        for flag in self.to_list(self.env['CXXFLAGS']):
162                if len(flag)<2:continue
163                f=flag[0:2]
164                if f in('-D','-I','/D','/I'):
165                        if(f[0]=='/'):
166                                lst.append('-'+flag[1:])
167                        else:
168                                lst.append(flag)
169        self.env.append_value('MOC_FLAGS',lst)
170@extension(*EXT_QT4)
171def cxx_hook(self,node):
172        return self.create_compiled_task('qxx',node)
173class rcc(Task.Task):
174        color='BLUE'
175        run_str='${QT_RCC} -name ${tsk.rcname()} ${SRC[0].abspath()} ${RCC_ST} -o ${TGT}'
176        ext_out=['.h']
177        def rcname(self):
178                return os.path.splitext(self.inputs[0].name)[0]
179        def scan(self):
180                if not has_xml:
181                        Logs.error('no xml support was found, the rcc dependencies will be incomplete!')
182                        return([],[])
183                parser=make_parser()
184                curHandler=XMLHandler()
185                parser.setContentHandler(curHandler)
186                fi=open(self.inputs[0].abspath(),'r')
187                try:
188                        parser.parse(fi)
189                finally:
190                        fi.close()
191                nodes=[]
192                names=[]
193                root=self.inputs[0].parent
194                for x in curHandler.files:
195                        nd=root.find_resource(x)
196                        if nd:nodes.append(nd)
197                        else:names.append(x)
198                return(nodes,names)
199class moc(Task.Task):
200        color='BLUE'
201        run_str='${QT_MOC} ${MOC_FLAGS} ${MOCCPPPATH_ST:INCPATHS} ${MOCDEFINES_ST:DEFINES} ${SRC} ${MOC_ST} ${TGT}'
202        def keyword(self):
203                return"Creating"
204        def __str__(self):
205                return self.outputs[0].path_from(self.generator.bld.launch_node())
206class ui4(Task.Task):
207        color='BLUE'
208        run_str='${QT_UIC} ${SRC} -o ${TGT}'
209        ext_out=['.h']
210class ts2qm(Task.Task):
211        color='BLUE'
212        run_str='${QT_LRELEASE} ${QT_LRELEASE_FLAGS} ${SRC} -qm ${TGT}'
213class qm2rcc(Task.Task):
214        color='BLUE'
215        after='ts2qm'
216        def run(self):
217                txt='\n'.join(['<file>%s</file>'%k.path_from(self.outputs[0].parent)for k in self.inputs])
218                code='<!DOCTYPE RCC><RCC version="1.0">\n<qresource>\n%s\n</qresource>\n</RCC>'%txt
219                self.outputs[0].write(code)
220def configure(self):
221        self.find_qt4_binaries()
222        self.set_qt4_libs_to_check()
223        self.set_qt4_defines()
224        self.find_qt4_libraries()
225        self.add_qt4_rpath()
226        self.simplify_qt4_libs()
227@conf
228def find_qt4_binaries(self):
229        env=self.env
230        opt=Options.options
231        qtdir=getattr(opt,'qtdir','')
232        qtbin=getattr(opt,'qtbin','')
233        paths=[]
234        if qtdir:
235                qtbin=os.path.join(qtdir,'bin')
236        if not qtdir:
237                qtdir=os.environ.get('QT4_ROOT','')
238                qtbin=os.environ.get('QT4_BIN',None)or os.path.join(qtdir,'bin')
239        if qtbin:
240                paths=[qtbin]
241        if not qtdir:
242                paths=os.environ.get('PATH','').split(os.pathsep)
243                paths.append('/usr/share/qt4/bin/')
244                try:
245                        lst=Utils.listdir('/usr/local/Trolltech/')
246                except OSError:
247                        pass
248                else:
249                        if lst:
250                                lst.sort()
251                                lst.reverse()
252                                qtdir='/usr/local/Trolltech/%s/'%lst[0]
253                                qtbin=os.path.join(qtdir,'bin')
254                                paths.append(qtbin)
255        cand=None
256        prev_ver=['4','0','0']
257        for qmk in('qmake-qt4','qmake4','qmake'):
258                try:
259                        qmake=self.find_program(qmk,path_list=paths)
260                except self.errors.ConfigurationError:
261                        pass
262                else:
263                        try:
264                                version=self.cmd_and_log(qmake+['-query','QT_VERSION']).strip()
265                        except self.errors.WafError:
266                                pass
267                        else:
268                                if version:
269                                        new_ver=version.split('.')
270                                        if new_ver>prev_ver:
271                                                cand=qmake
272                                                prev_ver=new_ver
273        if cand:
274                self.env.QMAKE=cand
275        else:
276                self.fatal('Could not find qmake for qt4')
277        qtbin=self.cmd_and_log(self.env.QMAKE+['-query','QT_INSTALL_BINS']).strip()+os.sep
278        def find_bin(lst,var):
279                if var in env:
280                        return
281                for f in lst:
282                        try:
283                                ret=self.find_program(f,path_list=paths)
284                        except self.errors.ConfigurationError:
285                                pass
286                        else:
287                                env[var]=ret
288                                break
289        find_bin(['uic-qt3','uic3'],'QT_UIC3')
290        find_bin(['uic-qt4','uic'],'QT_UIC')
291        if not env.QT_UIC:
292                self.fatal('cannot find the uic compiler for qt4')
293        self.start_msg('Checking for uic version')
294        uicver=self.cmd_and_log(env.QT_UIC+["-version"],output=Context.BOTH)
295        uicver=''.join(uicver).strip()
296        uicver=uicver.replace('Qt User Interface Compiler ','').replace('User Interface Compiler for Qt','')
297        self.end_msg(uicver)
298        if uicver.find(' 3.')!=-1:
299                self.fatal('this uic compiler is for qt3, add uic for qt4 to your path')
300        find_bin(['moc-qt4','moc'],'QT_MOC')
301        find_bin(['rcc-qt4','rcc'],'QT_RCC')
302        find_bin(['lrelease-qt4','lrelease'],'QT_LRELEASE')
303        find_bin(['lupdate-qt4','lupdate'],'QT_LUPDATE')
304        env['UIC3_ST']='%s -o %s'
305        env['UIC_ST']='%s -o %s'
306        env['MOC_ST']='-o'
307        env['ui_PATTERN']='ui_%s.h'
308        env['QT_LRELEASE_FLAGS']=['-silent']
309        env.MOCCPPPATH_ST='-I%s'
310        env.MOCDEFINES_ST='-D%s'
311@conf
312def find_qt4_libraries(self):
313        qtlibs=getattr(Options.options,'qtlibs',None)or os.environ.get("QT4_LIBDIR",None)
314        if not qtlibs:
315                try:
316                        qtlibs=self.cmd_and_log(self.env.QMAKE+['-query','QT_INSTALL_LIBS']).strip()
317                except Errors.WafError:
318                        qtdir=self.cmd_and_log(self.env.QMAKE+['-query','QT_INSTALL_PREFIX']).strip()+os.sep
319                        qtlibs=os.path.join(qtdir,'lib')
320        self.msg('Found the Qt4 libraries in',qtlibs)
321        qtincludes=os.environ.get("QT4_INCLUDES",None)or self.cmd_and_log(self.env.QMAKE+['-query','QT_INSTALL_HEADERS']).strip()
322        env=self.env
323        if not'PKG_CONFIG_PATH'in os.environ:
324                os.environ['PKG_CONFIG_PATH']='%s:%s/pkgconfig:/usr/lib/qt4/lib/pkgconfig:/opt/qt4/lib/pkgconfig:/usr/lib/qt4/lib:/opt/qt4/lib'%(qtlibs,qtlibs)
325        try:
326                if os.environ.get("QT4_XCOMPILE",None):
327                        raise self.errors.ConfigurationError()
328                self.check_cfg(atleast_pkgconfig_version='0.1')
329        except self.errors.ConfigurationError:
330                for i in self.qt4_vars:
331                        uselib=i.upper()
332                        if Utils.unversioned_sys_platform()=="darwin":
333                                frameworkName=i+".framework"
334                                qtDynamicLib=os.path.join(qtlibs,frameworkName,i)
335                                if os.path.exists(qtDynamicLib):
336                                        env.append_unique('FRAMEWORK_'+uselib,i)
337                                        self.msg('Checking for %s'%i,qtDynamicLib,'GREEN')
338                                else:
339                                        self.msg('Checking for %s'%i,False,'YELLOW')
340                                env.append_unique('INCLUDES_'+uselib,os.path.join(qtlibs,frameworkName,'Headers'))
341                        elif env.DEST_OS!="win32":
342                                qtDynamicLib=os.path.join(qtlibs,"lib"+i+".so")
343                                qtStaticLib=os.path.join(qtlibs,"lib"+i+".a")
344                                if os.path.exists(qtDynamicLib):
345                                        env.append_unique('LIB_'+uselib,i)
346                                        self.msg('Checking for %s'%i,qtDynamicLib,'GREEN')
347                                elif os.path.exists(qtStaticLib):
348                                        env.append_unique('LIB_'+uselib,i)
349                                        self.msg('Checking for %s'%i,qtStaticLib,'GREEN')
350                                else:
351                                        self.msg('Checking for %s'%i,False,'YELLOW')
352                                env.append_unique('LIBPATH_'+uselib,qtlibs)
353                                env.append_unique('INCLUDES_'+uselib,qtincludes)
354                                env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i))
355                        else:
356                                for k in("lib%s.a","lib%s4.a","%s.lib","%s4.lib"):
357                                        lib=os.path.join(qtlibs,k%i)
358                                        if os.path.exists(lib):
359                                                env.append_unique('LIB_'+uselib,i+k[k.find("%s")+2:k.find('.')])
360                                                self.msg('Checking for %s'%i,lib,'GREEN')
361                                                break
362                                else:
363                                        self.msg('Checking for %s'%i,False,'YELLOW')
364                                env.append_unique('LIBPATH_'+uselib,qtlibs)
365                                env.append_unique('INCLUDES_'+uselib,qtincludes)
366                                env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i))
367                                uselib=i.upper()+"_debug"
368                                for k in("lib%sd.a","lib%sd4.a","%sd.lib","%sd4.lib"):
369                                        lib=os.path.join(qtlibs,k%i)
370                                        if os.path.exists(lib):
371                                                env.append_unique('LIB_'+uselib,i+k[k.find("%s")+2:k.find('.')])
372                                                self.msg('Checking for %s'%i,lib,'GREEN')
373                                                break
374                                else:
375                                        self.msg('Checking for %s'%i,False,'YELLOW')
376                                env.append_unique('LIBPATH_'+uselib,qtlibs)
377                                env.append_unique('INCLUDES_'+uselib,qtincludes)
378                                env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i))
379        else:
380                for i in self.qt4_vars_debug+self.qt4_vars:
381                        self.check_cfg(package=i,args='--cflags --libs',mandatory=False)
382@conf
383def simplify_qt4_libs(self):
384        env=self.env
385        def process_lib(vars_,coreval):
386                for d in vars_:
387                        var=d.upper()
388                        if var=='QTCORE':
389                                continue
390                        value=env['LIBPATH_'+var]
391                        if value:
392                                core=env[coreval]
393                                accu=[]
394                                for lib in value:
395                                        if lib in core:
396                                                continue
397                                        accu.append(lib)
398                                env['LIBPATH_'+var]=accu
399        process_lib(self.qt4_vars,'LIBPATH_QTCORE')
400        process_lib(self.qt4_vars_debug,'LIBPATH_QTCORE_DEBUG')
401@conf
402def add_qt4_rpath(self):
403        env=self.env
404        if getattr(Options.options,'want_rpath',False):
405                def process_rpath(vars_,coreval):
406                        for d in vars_:
407                                var=d.upper()
408                                value=env['LIBPATH_'+var]
409                                if value:
410                                        core=env[coreval]
411                                        accu=[]
412                                        for lib in value:
413                                                if var!='QTCORE':
414                                                        if lib in core:
415                                                                continue
416                                                accu.append('-Wl,--rpath='+lib)
417                                        env['RPATH_'+var]=accu
418                process_rpath(self.qt4_vars,'LIBPATH_QTCORE')
419                process_rpath(self.qt4_vars_debug,'LIBPATH_QTCORE_DEBUG')
420@conf
421def set_qt4_libs_to_check(self):
422        if not hasattr(self,'qt4_vars'):
423                self.qt4_vars=QT4_LIBS
424        self.qt4_vars=Utils.to_list(self.qt4_vars)
425        if not hasattr(self,'qt4_vars_debug'):
426                self.qt4_vars_debug=[a+'_debug'for a in self.qt4_vars]
427        self.qt4_vars_debug=Utils.to_list(self.qt4_vars_debug)
428@conf
429def set_qt4_defines(self):
430        if sys.platform!='win32':
431                return
432        for x in self.qt4_vars:
433                y=x[2:].upper()
434                self.env.append_unique('DEFINES_%s'%x.upper(),'QT_%s_LIB'%y)
435                self.env.append_unique('DEFINES_%s_DEBUG'%x.upper(),'QT_%s_LIB'%y)
436def options(opt):
437        opt.add_option('--want-rpath',action='store_true',default=False,dest='want_rpath',help='enable the rpath for qt libraries')
438        opt.add_option('--header-ext',type='string',default='',help='header extension for moc files',dest='qt_header_ext')
439        for i in'qtdir qtbin qtlibs'.split():
440                opt.add_option('--'+i,type='string',default='',dest=i)
441        opt.add_option('--translate',action="store_true",help="collect translation strings",dest="trans_qt4",default=False)
Note: See TracBrowser for help on using the repository browser.