← Back to branch summary

~ubuntu-branches/ubuntu/trusty/xiphos/trusty

« back to all changes in this revision

Viewing changes to wafadmin/Tools/vala.py

  • Committer: Package Import Robot
  • Author(s): Dmitrijs Ledkovs, Dmitrijs Ledkovs
  • Date: 2012-03-11 18:43:32 UTC
  • mfrom: (17.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20120311184332-splq3ecpx7tyi87d
Tags: 3.1.5+dfsg-1
http://bugs.debian.org/654511
[ Dmitrijs Ledkovs <dmitrij.ledkov@ubuntu.com> ]  
* New upstream release.
* Build using webkit backend
* Contains unpacked source for waf binary (Closes: #654511)
* Update debian/copyright to latest specification

Show diffs side-by-side

added added

removed removed

Lines of Context:
wafadmin/Tools/vala.py
 
1
#! /usr/bin/env python
 
2
# encoding: utf-8
 
3
 
 
4
import os.path,shutil
 
5
import Task,Runner,Utils,Logs,Build,Node,Options
 
6
from TaskGen import extension,after,before
 
7
EXT_VALA=['.vala','.gs']
 
8
class valac_task(Task.Task):
 
9
        vars=("VALAC","VALAC_VERSION","VALAFLAGS")
 
10
        before=("cc","cxx")
 
11
        def run(self):
 
12
                env=self.env
 
13
                inputs=[a.srcpath(env)for a in self.inputs]
 
14
                valac=env['VALAC']
 
15
                vala_flags=env.get_flat('VALAFLAGS')
 
16
                top_src=self.generator.bld.srcnode.abspath()
 
17
                top_bld=self.generator.bld.srcnode.abspath(env)
 
18
                if env['VALAC_VERSION']>(0,1,6):
 
19
                        cmd=[valac,'-C','--quiet',vala_flags]
 
20
                else:
 
21
                        cmd=[valac,'-C',vala_flags]
 
22
                if self.threading:
 
23
                        cmd.append('--thread')
 
24
                if self.profile:
 
25
                        cmd.append('--profile=%s'%self.profile)
 
26
                if self.target_glib:
 
27
                        cmd.append('--target-glib=%s'%self.target_glib)
 
28
                features=self.generator.features
 
29
                if'cshlib'in features or'cstaticlib'in features:
 
30
                        output_dir=self.outputs[0].bld_dir(env)
 
31
                        cmd.append('--library '+self.target)
 
32
                        if env['VALAC_VERSION']>=(0,7,0):
 
33
                                cmd.append('--header '+os.path.join(output_dir,self.target+'.h'))
 
34
                                self.outputs.append(self.generator.path.find_or_declare(self.target+'.h'))
 
35
                        cmd.append('--basedir '+top_src)
 
36
                        cmd.append('-d '+top_bld)
 
37
                        if env['VALAC_VERSION']>(0,7,2)and hasattr(self,'gir'):
 
38
                                cmd.append('--gir=%s.gir'%self.gir)
 
39
                else:
 
40
                        output_dir=self.outputs[0].bld_dir(env)
 
41
                        cmd.append('-d %s'%output_dir)
 
42
                for vapi_dir in self.vapi_dirs:
 
43
                        cmd.append('--vapidir=%s'%vapi_dir)
 
44
                for package in self.packages:
 
45
                        cmd.append('--pkg %s'%package)
 
46
                for package in self.packages_private:
 
47
                        cmd.append('--pkg %s'%package)
 
48
                cmd.append(" ".join(inputs))
 
49
                result=self.generator.bld.exec_command(" ".join(cmd))
 
50
                if not'cprogram'in features:
 
51
                        if self.packages:
 
52
                                filename=os.path.join(self.generator.path.abspath(env),"%s.deps"%self.target)
 
53
                                deps=open(filename,'w')
 
54
                                for package in self.packages:
 
55
                                        deps.write(package+'\n')
 
56
                                deps.close()
 
57
                        self._fix_output("../%s.vapi"%self.target)
 
58
                        self._fix_output("%s.vapi"%self.target)
 
59
                        self._fix_output("%s.gidl"%self.target)
 
60
                        self._fix_output("%s.gir"%self.target)
 
61
                        if hasattr(self,'gir'):
 
62
                                self._fix_output("%s.gir"%self.gir)
 
63
                first=None
 
64
                for node in self.outputs:
 
65
                        if not first:
 
66
                                first=node
 
67
                        else:
 
68
                                if first.parent.id!=node.parent.id:
 
69
                                        if env['VALAC_VERSION']<(0,7,0):
 
70
                                                shutil.move(first.parent.abspath(self.env)+os.sep+node.name,node.abspath(self.env))
 
71
                return result
 
72
        def install(self):
 
73
                bld=self.generator.bld
 
74
                features=self.generator.features
 
75
                if self.attr("install_path")and("cshlib"in features or"cstaticlib"in features):
 
76
                        headers_list=[o for o in self.outputs if o.suffix()==".h"]
 
77
                        vapi_list=[o for o in self.outputs if(o.suffix()in(".vapi",".deps"))]
 
78
                        gir_list=[o for o in self.outputs if o.suffix()==".gir"]
 
79
                        for header in headers_list:
 
80
                                top_src=self.generator.bld.srcnode
 
81
                                package=self.env['PACKAGE']
 
82
                                try:
 
83
                                        api_version=Utils.g_module.API_VERSION
 
84
                                except AttributeError:
 
85
                                        version=Utils.g_module.VERSION.split(".")
 
86
                                        if version[0]=="0":
 
87
                                                api_version="0."+version[1]
 
88
                                        else:
 
89
                                                api_version=version[0]+".0"
 
90
                                install_path='${INCLUDEDIR}/%s-%s/%s'%(package,api_version,header.relpath_gen(top_src))
 
91
                                bld.install_as(install_path,header,self.env)
 
92
                        bld.install_files('${DATAROOTDIR}/vala/vapi',vapi_list,self.env)
 
93
                        bld.install_files('${DATAROOTDIR}/gir-1.0',gir_list,self.env)
 
94
        def _fix_output(self,output):
 
95
                top_bld=self.generator.bld.srcnode.abspath(self.env)
 
96
                try:
 
97
                        src=os.path.join(top_bld,output)
 
98
                        dst=self.generator.path.abspath(self.env)
 
99
                        shutil.move(src,dst)
 
100
                except:
 
101
                        pass
 
102
def vala_file(self,node):
 
103
        valatask=getattr(self,"valatask",None)
 
104
        if not valatask:
 
105
                valatask=self.create_task('valac')
 
106
                self.valatask=valatask
 
107
                self.includes=Utils.to_list(getattr(self,'includes',[]))
 
108
                self.uselib=self.to_list(self.uselib)
 
109
                valatask.packages=[]
 
110
                valatask.packages_private=Utils.to_list(getattr(self,'packages_private',[]))
 
111
                valatask.vapi_dirs=[]
 
112
                valatask.target=self.target
 
113
                valatask.threading=False
 
114
                valatask.install_path=self.install_path
 
115
                valatask.profile=getattr(self,'profile','gobject')
 
116
                valatask.target_glib=None
 
117
                packages=Utils.to_list(getattr(self,'packages',[]))
 
118
                vapi_dirs=Utils.to_list(getattr(self,'vapi_dirs',[]))
 
119
                includes=[]
 
120
                if hasattr(self,'uselib_local'):
 
121
                        local_packages=Utils.to_list(self.uselib_local)
 
122
                        seen=[]
 
123
                        while len(local_packages)>0:
 
124
                                package=local_packages.pop()
 
125
                                if package in seen:
 
126
                                        continue
 
127
                                seen.append(package)
 
128
                                package_obj=self.name_to_obj(package)
 
129
                                if not package_obj:
 
130
                                        raise Utils.WafError("object '%s' was not found in uselib_local (required by '%s')"%(package,self.name))
 
131
                                package_name=package_obj.target
 
132
                                package_node=package_obj.path
 
133
                                package_dir=package_node.relpath_gen(self.path)
 
134
                                for task in package_obj.tasks:
 
135
                                        for output in task.outputs:
 
136
                                                if output.name==package_name+".vapi":
 
137
                                                        valatask.set_run_after(task)
 
138
                                                        if package_name not in packages:
 
139
                                                                packages.append(package_name)
 
140
                                                        if package_dir not in vapi_dirs:
 
141
                                                                vapi_dirs.append(package_dir)
 
142
                                                        if package_dir not in includes:
 
143
                                                                includes.append(package_dir)
 
144
                                if hasattr(package_obj,'uselib_local'):
 
145
                                        lst=self.to_list(package_obj.uselib_local)
 
146
                                        lst.reverse()
 
147
                                        local_packages=[pkg for pkg in lst if pkg not in seen]+local_packages
 
148
                valatask.packages=packages
 
149
                for vapi_dir in vapi_dirs:
 
150
                        try:
 
151
                                valatask.vapi_dirs.append(self.path.find_dir(vapi_dir).abspath())
 
152
                                valatask.vapi_dirs.append(self.path.find_dir(vapi_dir).abspath(self.env))
 
153
                        except AttributeError:
 
154
                                Logs.warn("Unable to locate Vala API directory: '%s'"%vapi_dir)
 
155
                self.includes.append(node.bld.srcnode.abspath())
 
156
                self.includes.append(node.bld.srcnode.abspath(self.env))
 
157
                for include in includes:
 
158
                        try:
 
159
                                self.includes.append(self.path.find_dir(include).abspath())
 
160
                                self.includes.append(self.path.find_dir(include).abspath(self.env))
 
161
                        except AttributeError:
 
162
                                Logs.warn("Unable to locate include directory: '%s'"%include)
 
163
                if valatask.profile=='gobject':
 
164
                        if hasattr(self,'target_glib'):
 
165
                                Logs.warn('target_glib on vala tasks is deprecated --vala-target-glib=MAJOR.MINOR from the vala tool options')
 
166
                        if getattr(Options.options,'vala_target_glib',None):
 
167
                                valatask.target_glib=Options.options.vala_target_glib
 
168
                        if not'GOBJECT'in self.uselib:
 
169
                                self.uselib.append('GOBJECT')
 
170
                if hasattr(self,'threading'):
 
171
                        if valatask.profile=='gobject':
 
172
                                valatask.threading=self.threading
 
173
                                if not'GTHREAD'in self.uselib:
 
174
                                        self.uselib.append('GTHREAD')
 
175
                        else:
 
176
                                Logs.warn("Profile %s does not have threading support"%valatask.profile)
 
177
                if hasattr(self,'gir'):
 
178
                        valatask.gir=self.gir
 
179
        env=valatask.env
 
180
        output_nodes=[]
 
181
        c_node=node.change_ext('.c')
 
182
        output_nodes.append(c_node)
 
183
        self.allnodes.append(c_node)
 
184
        if env['VALAC_VERSION']<(0,7,0):
 
185
                output_nodes.append(node.change_ext('.h'))
 
186
        else:
 
187
                if not'cprogram'in self.features:
 
188
                        output_nodes.append(self.path.find_or_declare('%s.h'%self.target))
 
189
        if not'cprogram'in self.features:
 
190
                output_nodes.append(self.path.find_or_declare('%s.vapi'%self.target))
 
191
                if env['VALAC_VERSION']>(0,7,2):
 
192
                        if hasattr(self,'gir'):
 
193
                                output_nodes.append(self.path.find_or_declare('%s.gir'%self.gir))
 
194
                elif env['VALAC_VERSION']>(0,3,5):
 
195
                        output_nodes.append(self.path.find_or_declare('%s.gir'%self.target))
 
196
                elif env['VALAC_VERSION']>(0,1,7):
 
197
                        output_nodes.append(self.path.find_or_declare('%s.gidl'%self.target))
 
198
                if valatask.packages:
 
199
                        output_nodes.append(self.path.find_or_declare('%s.deps'%self.target))
 
200
        valatask.inputs.append(node)
 
201
        valatask.outputs.extend(output_nodes)
 
202
def detect(conf):
 
203
        min_version=(0,1,6)
 
204
        min_version_str="%d.%d.%d"%min_version
 
205
        valac=conf.find_program('valac',var='VALAC',mandatory=True)
 
206
        if not conf.env["HAVE_GOBJECT"]:
 
207
                pkg_args={'package':'gobject-2.0','uselib_store':'GOBJECT','args':'--cflags --libs'}
 
208
                if getattr(Options.options,'vala_target_glib',None):
 
209
                        pkg_args['atleast_version']=Options.options.vala_target_glib
 
210
                conf.check_cfg(**pkg_args)
 
211
        if not conf.env["HAVE_GTHREAD"]:
 
212
                pkg_args={'package':'gthread-2.0','uselib_store':'GTHREAD','args':'--cflags --libs'}
 
213
                if getattr(Options.options,'vala_target_glib',None):
 
214
                        pkg_args['atleast_version']=Options.options.vala_target_glib
 
215
                conf.check_cfg(**pkg_args)
 
216
        try:
 
217
                output=Utils.cmd_output(valac+" --version",silent=True)
 
218
                version=output.split(' ',1)[-1].strip().split(".")
 
219
                version=[int(x)for x in version]
 
220
                valac_version=tuple(version)
 
221
        except Exception:
 
222
                valac_version=(0,0,0)
 
223
        conf.check_message('program version','valac >= '+min_version_str,valac_version>=min_version,"%d.%d.%d"%valac_version)
 
224
        conf.check_tool('gnu_dirs')
 
225
        if valac_version<min_version:
 
226
                conf.fatal("valac version too old to be used with this tool")
 
227
                return
 
228
        conf.env['VALAC_VERSION']=valac_version
 
229
        conf.env['VALAFLAGS']=''
 
230
def set_options(opt):
 
231
        valaopts=opt.add_option_group('Vala Compiler Options')
 
232
        valaopts.add_option('--vala-target-glib',default=None,dest='vala_target_glib',metavar='MAJOR.MINOR',help='Target version of glib for Vala GObject code generation')
 
233
 
 
234
extension(EXT_VALA)(vala_file)