node/tools/wafadmin/Tools/ccroot.py at master · elarkin/node · GitHub

Repository navigation

History

625 lines (518 loc) · 18.2 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

452

453

454

455

456

457

458

459

460

461

462

463

464

465

466

467

468

469

470

471

472

473

474

475

476

477

478

479

480

481

482

483

484

485

486

487

488

489

490

491

492

493

494

495

496

497

498

499

500

501

502

503

504

505

506

507

508

509

510

511

512

513

514

515

516

517

518

519

520

521

522

523

524

525

526

527

528

529

530

531

532

533

534

535

536

537

538

539

540

541

542

543

544

545

546

547

548

549

550

551

552

553

554

555

556

557

558

559

560

561

562

563

564

565

566

567

568

569

570

571

572

573

574

575

576

577

578

579

580

581

582

583

584

585

586

587

588

589

590

591

592

593

594

595

596

597

598

599

600

601

602

603

604

605

606

607

608

609

610

611

612

613

614

615

616

617

618

619

620

621

622

623

624

#!/usr/bin/env python

# encoding: utf-8

# Thomas Nagy, 2005-2008 (ita)

"base for all c/c++ programs and libraries"

import os, sys, re

import TaskGen, Task, Utils, preproc, Logs, Build, Options

from Logs import error, debug, warn

from Utils import md5

from TaskGen import taskgen, after, before, feature

from Constants import *

from Configure import conftest

try:

from cStringIO import StringIO

except ImportError:

from io import StringIO

import config_c # <- necessary for the configuration, do not touch

USE_TOP_LEVEL = False

def get_cc_version(conf, cc, gcc=False, icc=False):

cmd = cc + ['-dM', '-E', '-']

try:

p = Utils.pproc.Popen(cmd, stdin=Utils.pproc.PIPE, stdout=Utils.pproc.PIPE, stderr=Utils.pproc.PIPE)

p.stdin.write('\n')

out = p.communicate()[0]

except:

conf.fatal('could not determine the compiler version %r' % cmd)

# PY3K: do not touch

out = str(out)

if gcc:

if out.find('__INTEL_COMPILER') >= 0:

conf.fatal('The intel compiler pretends to be gcc')

if out.find('__GNUC__') < 0:

conf.fatal('Could not determine the compiler type')

if icc and out.find('__INTEL_COMPILER') < 0:

conf.fatal('Not icc/icpc')

k = {}

if icc or gcc:

out = out.split('\n')

import shlex

for line in out:

lst = shlex.split(line)

if len(lst)>2:

key = lst[1]

val = lst[2]

k[key] = val

def isD(var):

return var in k

def isT(var):

return var in k and k[var] != '0'

# Some documentation is available at http://predef.sourceforge.net

# The names given to DEST_OS must match what Utils.unversioned_sys_platform() returns.

mp1 = {

'__linux__' : 'linux',

'__GNU__' : 'hurd',

'__FreeBSD__' : 'freebsd',

'__NetBSD__' : 'netbsd',

'__OpenBSD__' : 'openbsd',

'__sun' : 'sunos',

'__hpux' : 'hpux',

'__sgi' : 'irix',

'_AIX' : 'aix',

'__CYGWIN__' : 'cygwin',

'__MSYS__' : 'msys',

'_UWIN' : 'uwin',

'_WIN64' : 'win32',

'_WIN32' : 'win32',

}

for i in mp1:

if isD(i):

conf.env.DEST_OS = mp1[i]

break

else:

if isD('__APPLE__') and isD('__MACH__'):

conf.env.DEST_OS = 'darwin'

elif isD('__unix__'): # unix must be tested last as it's a generic fallback

conf.env.DEST_OS = 'generic'

if isD('__ELF__'):

conf.env.DEST_BINFMT = 'elf'

mp2 = {

'__x86_64__' : 'x86_64',

'__i386__' : 'x86',

'__ia64__' : 'ia',

'__mips__' : 'mips',

'__sparc__' : 'sparc',

'__alpha__' : 'alpha',

'__arm__' : 'arm',

'__hppa__' : 'hppa',

'__powerpc__' : 'powerpc',

}

for i in mp2:

if isD(i):

conf.env.DEST_CPU = mp2[i]

break

debug('ccroot: dest platform: ' + ' '.join([conf.env[x] or '?' for x in ('DEST_OS', 'DEST_BINFMT', 'DEST_CPU')]))

conf.env['CC_VERSION'] = (k['__GNUC__'], k['__GNUC_MINOR__'], k['__GNUC_PATCHLEVEL__'])

return k

class DEBUG_LEVELS:

"""Will disappear in waf 1.6"""

ULTRADEBUG = "ultradebug"

DEBUG = "debug"

RELEASE = "release"

OPTIMIZED = "optimized"

CUSTOM = "custom"

ALL = [ULTRADEBUG, DEBUG, RELEASE, OPTIMIZED, CUSTOM]

def scan(self):

"look for .h the .cpp need"

debug('ccroot: _scan_preprocessor(self, node, env, path_lst)')

# TODO waf 1.6 - assume the default input has exactly one file

if len(self.inputs) == 1:

node = self.inputs[0]

(nodes, names) = preproc.get_deps(node, self.env, nodepaths = self.env['INC_PATHS'])

if Logs.verbose:

debug('deps: deps for %s: %r; unresolved %r', str(node), nodes, names)

return (nodes, names)

all_nodes = []

all_names = []

seen = set()

for node in self.inputs:

(nodes, names) = preproc.get_deps(node, self.env, nodepaths = self.env['INC_PATHS'])

if Logs.verbose:

debug('deps: deps for %s: %r; unresolved %r', str(node), nodes, names)

for x in nodes:

if id(x) in seen: continue

seen.add(id(x))

all_nodes.append(x)

for x in names:

if not x in all_names:

all_names.append(x)

return (all_nodes, all_names)

class ccroot_abstract(TaskGen.task_gen):

"Parent class for programs and libraries in languages c, c++ and moc (Qt)"

def __init__(self, *k, **kw):

# COMPAT remove in waf 1.6 TODO

if len(k) > 1:

k = list(k)

if k[1][0] != 'c':

k[1] = 'c' + k[1]

TaskGen.task_gen.__init__(self, *k, **kw)

def get_target_name(self):

tp = 'program'

for x in self.features:

if x in ['cshlib', 'cstaticlib']:

tp = x.lstrip('c')

pattern = self.env[tp + '_PATTERN']

if not pattern: pattern = '%s'

dir, name = os.path.split(self.target)

if self.env.DEST_BINFMT == 'pe' and getattr(self, 'vnum', None) and 'cshlib' in self.features:

# include the version in the dll file name,

# the import lib file name stays unversionned.

name = name + '-' + self.vnum.split('.')[0]

return os.path.join(dir, pattern % name)

@feature('cc', 'cxx')

@before('apply_core')

def default_cc(self):

"""compiled_tasks attribute must be set before the '.c->.o' tasks can be created"""

Utils.def_attrs(self,

includes = '',

defines= '',

rpaths = '',

uselib = '',

uselib_local = '',

add_objects = '',

p_flag_vars = [],

p_type_vars = [],

compiled_tasks = [],

link_task = None)

# The only thing we need for cross-compilation is DEST_BINFMT.

# At some point, we may reach a case where DEST_BINFMT is not enough, but for now it's sufficient.

# Currently, cross-compilation is auto-detected only for the gnu and intel compilers.

if not self.env.DEST_BINFMT:

# Infer the binary format from the os name.

self.env.DEST_BINFMT = Utils.unversioned_sys_platform_to_binary_format(

self.env.DEST_OS or Utils.unversioned_sys_platform())

if not self.env.BINDIR: self.env.BINDIR = Utils.subst_vars('${PREFIX}/bin', self.env)

if not self.env.LIBDIR: self.env.LIBDIR = Utils.subst_vars('${PREFIX}/lib${LIB_EXT}', self.env)

@feature('cprogram', 'dprogram', 'cstaticlib', 'dstaticlib', 'cshlib', 'dshlib')

def apply_verif(self):

"""no particular order, used for diagnostic"""

if not (self.source or getattr(self, 'add_objects', None) or getattr(self, 'uselib_local', None) or getattr(self, 'obj_files', None)):

raise Utils.WafError('no source files specified for %s' % self)

if not self.target:

raise Utils.WafError('no target for %s' % self)

# TODO reference the d programs, shlibs in d.py, not here

@feature('cprogram', 'dprogram')

@after('default_cc')

@before('apply_core')

def vars_target_cprogram(self):

self.default_install_path = self.env.BINDIR

self.default_chmod = O755

@after('default_cc')

@feature('cshlib', 'dshlib')

@before('apply_core')

def vars_target_cshlib(self):

if self.env.DEST_BINFMT == 'pe':

# set execute bit on libs to avoid 'permission denied' (issue 283)

self.default_chmod = O755

self.default_install_path = self.env.BINDIR

else:

self.default_install_path = self.env.LIBDIR

@feature('cprogram', 'dprogram', 'cstaticlib', 'dstaticlib', 'cshlib', 'dshlib')

@after('apply_link', 'vars_target_cprogram', 'vars_target_cshlib')

def default_link_install(self):

"""you may kill this method to inject your own installation for the first element

any other install should only process its own nodes and not those from the others"""

if self.install_path:

self.bld.install_files(self.install_path, self.link_task.outputs[0], env=self.env, chmod=self.chmod)

@feature('cc', 'cxx')

@after('apply_type_vars', 'apply_lib_vars', 'apply_core')

def apply_incpaths(self):

"""used by the scanner

after processing the uselib for CPPPATH

after apply_core because some processing may add include paths

"""

lst = []

# TODO move the uselib processing out of here

for lib in self.to_list(self.uselib):

for path in self.env['CPPPATH_' + lib]:

if not path in lst:

lst.append(path)

if preproc.go_absolute:

for path in preproc.standard_includes:

if not path in lst:

lst.append(path)

for path in self.to_list(self.includes):

if not path in lst:

if preproc.go_absolute or not os.path.isabs(path):

lst.append(path)

else:

self.env.prepend_value('CPPPATH', path)

for path in lst:

node = None

if os.path.isabs(path):

if preproc.go_absolute:

node = self.bld.root.find_dir(path)

elif path[0] == '#':

node = self.bld.srcnode

if len(path) > 1:

node = node.find_dir(path[1:])

else:

node = self.path.find_dir(path)

if node:

self.env.append_value('INC_PATHS', node)

# TODO WAF 1.6

if USE_TOP_LEVEL:

self.env.append_value('INC_PATHS', self.bld.srcnode)

@feature('cc', 'cxx')

@after('init_cc', 'init_cxx')

@before('apply_lib_vars')

def apply_type_vars(self):

"""before apply_lib_vars because we modify uselib

after init_cc and init_cxx because web need p_type_vars

"""

for x in self.features:

if not x in ['cprogram', 'cstaticlib', 'cshlib']:

continue

x = x.lstrip('c')

# if the type defines uselib to add, add them

st = self.env[x + '_USELIB']

if st: self.uselib = self.uselib + ' ' + st

# each compiler defines variables like 'shlib_CXXFLAGS', 'shlib_LINKFLAGS', etc

# so when we make a task generator of the type shlib, CXXFLAGS are modified accordingly

for var in self.p_type_vars:

compvar = '%s_%s' % (x, var)

#print compvar

value = self.env[compvar]

if value: self.env.append_value(var, value)

@feature('cprogram', 'cshlib', 'cstaticlib')

@after('apply_core')

def apply_link(self):

"""executes after apply_core for collecting 'compiled_tasks'

use a custom linker if specified (self.link='name-of-custom-link-task')"""

link = getattr(self, 'link', None)

if not link:

if 'cstaticlib' in self.features: link = 'static_link'

elif 'cxx' in self.features: link = 'cxx_link'

else: link = 'cc_link'

tsk = self.create_task(link)

outputs = [t.outputs[0] for t in self.compiled_tasks]

tsk.set_inputs(outputs)

tsk.set_outputs(self.path.find_or_declare(get_target_name(self)))

self.link_task = tsk

@feature('cc', 'cxx')

@after('apply_link', 'init_cc', 'init_cxx', 'apply_core')

def apply_lib_vars(self):

"""after apply_link because of 'link_task'

after default_cc because of the attribute 'uselib'"""

# after 'apply_core' in case if 'cc' if there is no link

env = self.env

# 1. the case of the libs defined in the project (visit ancestors first)

# the ancestors external libraries (uselib) will be prepended

self.uselib = self.to_list(self.uselib)

names = self.to_list(self.uselib_local)

seen = set([])

tmp = Utils.deque(names) # consume a copy of the list of names

while tmp:

lib_name = tmp.popleft()

# visit dependencies only once

if lib_name in seen:

continue

y = self.name_to_obj(lib_name)

if not y:

raise Utils.WafError('object %r was not found in uselib_local (required by %r)' % (lib_name, self.name))

y.post()

seen.add(lib_name)

# object has ancestors to process (shared libraries): add them to the end of the list

if getattr(y, 'uselib_local', None):

lst = y.to_list(y.uselib_local)

if 'cshlib' in y.features or 'cprogram' in y.features:

lst = [x for x in lst if not 'cstaticlib' in self.name_to_obj(x).features]

tmp.extend(lst)

# link task and flags

if getattr(y, 'link_task', None):

link_name = y.target[y.target.rfind(os.sep) + 1:]

if 'cstaticlib' in y.features:

env.append_value('STATICLIB', link_name)

elif 'cshlib' in y.features or 'cprogram' in y.features:

# WARNING some linkers can link against programs

env.append_value('LIB', link_name)

# the order

self.link_task.set_run_after(y.link_task)

# for the recompilation

dep_nodes = getattr(self.link_task, 'dep_nodes', [])

self.link_task.dep_nodes = dep_nodes + y.link_task.outputs

# add the link path too

tmp_path = y.link_task.outputs[0].parent.bldpath(self.env)

if not tmp_path in env['LIBPATH']: env.prepend_value('LIBPATH', tmp_path)

# add ancestors uselib too - but only propagate those that have no staticlib

for v in self.to_list(y.uselib):

if not env['STATICLIB_' + v]:

if not v in self.uselib:

self.uselib.insert(0, v)

# if the library task generator provides 'export_incdirs', add to the include path

# the export_incdirs must be a list of paths relative to the other library

if getattr(y, 'export_incdirs', None):

for x in self.to_list(y.export_incdirs):

node = y.path.find_dir(x)

if not node:

raise Utils.WafError('object %r: invalid folder %r in export_incdirs' % (y.target, x))

self.env.append_unique('INC_PATHS', node)

# 2. the case of the libs defined outside

for x in self.uselib:

for v in self.p_flag_vars:

val = self.env[v + '_' + x]

if val: self.env.append_value(v, val)

@feature('cprogram', 'cstaticlib', 'cshlib')

@after('init_cc', 'init_cxx', 'apply_link')

def apply_objdeps(self):

"add the .o files produced by some other object files in the same manner as uselib_local"

if not getattr(self, 'add_objects', None): return

seen = []

names = self.to_list(self.add_objects)

while names:

x = names[0]

# visit dependencies only once

if x in seen:

names = names[1:]

continue

# object does not exist ?

y = self.name_to_obj(x)

if not y:

raise Utils.WafError('object %r was not found in uselib_local (required by add_objects %r)' % (x, self.name))

# object has ancestors to process first ? update the list of names

if getattr(y, 'add_objects', None):

added = 0

lst = y.to_list(y.add_objects)

lst.reverse()

for u in lst:

if u in seen: continue

added = 1

names = [u]+names

if added: continue # list of names modified, loop

# safe to process the current object

y.post()

seen.append(x)

for t in y.compiled_tasks:

self.link_task.inputs.extend(t.outputs)

@feature('cprogram', 'cshlib', 'cstaticlib')

@after('apply_lib_vars')

def apply_obj_vars(self):

"""after apply_lib_vars for uselib"""

v = self.env

lib_st = v['LIB_ST']

staticlib_st = v['STATICLIB_ST']

libpath_st = v['LIBPATH_ST']

staticlibpath_st = v['STATICLIBPATH_ST']

rpath_st = v['RPATH_ST']

app = v.append_unique

if v['FULLSTATIC']:

v.append_value('LINKFLAGS', v['FULLSTATIC_MARKER'])

for i in v['RPATH']:

if i and rpath_st:

app('LINKFLAGS', rpath_st % i)

for i in v['LIBPATH']:

app('LINKFLAGS', libpath_st % i)

app('LINKFLAGS', staticlibpath_st % i)

if v['STATICLIB']:

v.append_value('LINKFLAGS', v['STATICLIB_MARKER'])

k = [(staticlib_st % i) for i in v['STATICLIB']]

app('LINKFLAGS', k)

# fully static binaries ?

if not v['FULLSTATIC']:

if v['STATICLIB'] or v['LIB']:

v.append_value('LINKFLAGS', v['SHLIB_MARKER'])

app('LINKFLAGS', [lib_st % i for i in v['LIB']])

@after('apply_link')

def process_obj_files(self):

if not hasattr(self, 'obj_files'): return

for x in self.obj_files:

node = self.path.find_resource(x)

self.link_task.inputs.append(node)

@taskgen

def add_obj_file(self, file):

"""Small example on how to link object files as if they were source

obj = bld.create_obj('cc')

obj.add_obj_file('foo.o')"""

if not hasattr(self, 'obj_files'): self.obj_files = []

if not 'process_obj_files' in self.meths: self.meths.append('process_obj_files')

self.obj_files.append(file)

c_attrs = {

'cxxflag' : 'CXXFLAGS',

'cflag' : 'CCFLAGS',

'ccflag' : 'CCFLAGS',

'linkflag' : 'LINKFLAGS',

'ldflag' : 'LINKFLAGS',

'lib' : 'LIB',

'libpath' : 'LIBPATH',

'staticlib': 'STATICLIB',

'staticlibpath': 'STATICLIBPATH',

'rpath' : 'RPATH',

'framework' : 'FRAMEWORK',

'frameworkpath' : 'FRAMEWORKPATH'

}

@feature('cc', 'cxx')

@before('init_cxx', 'init_cc')

@before('apply_lib_vars', 'apply_obj_vars', 'apply_incpaths', 'init_cc')

def add_extra_flags(self):

"""case and plural insensitive

before apply_obj_vars for processing the library attributes

"""

for x in self.__dict__.keys():

y = x.lower()

if y[-1] == 's':

y = y[:-1]

if c_attrs.get(y, None):

self.env.append_unique(c_attrs[y], getattr(self, x))

# ============ the code above must not know anything about import libs ==========

@feature('cshlib')

@after('apply_link', 'default_cc')

@before('apply_lib_vars', 'apply_objdeps', 'default_link_install')

def apply_implib(self):

"""On mswindows, handle dlls and their import libs

the .dll.a is the import lib and it is required for linking so it is installed too

"""

if not self.env.DEST_BINFMT == 'pe':

return

self.meths.remove('default_link_install')

bindir = self.install_path

if not bindir: return

# install the dll in the bin dir

dll = self.link_task.outputs[0]

self.bld.install_files(bindir, dll, self.env, self.chmod)

# add linker flags to generate the import lib

implib = self.env['implib_PATTERN'] % os.path.split(self.target)[1]

implib = dll.parent.find_or_declare(implib)

self.link_task.outputs.append(implib)

self.bld.install_as('${LIBDIR}/%s' % implib.name, implib, self.env)

self.env.append_value('LINKFLAGS', (self.env['IMPLIB_ST'] % implib.bldpath(self.env)).split())

# ============ the code above must not know anything about vnum processing on unix platforms =========

@feature('cshlib')

@after('apply_link')

@before('apply_lib_vars', 'default_link_install')

def apply_vnum(self):

"""

libfoo.so is installed as libfoo.so.1.2.3

"""

if not getattr(self, 'vnum', '') or not 'cshlib' in self.features or os.name != 'posix' or self.env.DEST_BINFMT not in ('elf', 'mac-o'):

return

self.meths.remove('default_link_install')

link = self.link_task

nums = self.vnum.split('.')

node = link.outputs[0]

libname = node.name

if libname.endswith('.dylib'):

name3 = libname.replace('.dylib', '.%s.dylib' % self.vnum)

name2 = libname.replace('.dylib', '.%s.dylib' % nums[0])

else:

name3 = libname + '.' + self.vnum

name2 = libname + '.' + nums[0]

if self.env.SONAME_ST:

v = self.env.SONAME_ST % name2

self.env.append_value('LINKFLAGS', v.split())

bld = self.bld

nums = self.vnum.split('.')

path = self.install_path

if not path: return

bld.install_as(path + os.sep + name3, node, env=self.env)

bld.symlink_as(path + os.sep + name2, name3)

bld.symlink_as(path + os.sep + libname, name3)

# the following task is just to enable execution from the build dir :-/

tsk = self.create_task('vnum')

tsk.set_inputs([node])

tsk.set_outputs(node.parent.find_or_declare(name2))

def exec_vnum_link(self):

path = self.outputs[0].abspath(self.env)

try:

os.remove(path)

except OSError:

pass

try:

os.symlink(self.inputs[0].name, path)

except OSError:

return 1

cls = Task.task_type_from_func('vnum', func=exec_vnum_link, ext_in='.bin', color='CYAN')

cls.quiet = 1

# ============ the --as-needed flag should added during the configuration, not at runtime =========

@conftest

def add_as_needed(conf):

if conf.env.DEST_BINFMT == 'elf' and 'gcc' in (conf.env.CXX_NAME, conf.env.CC_NAME):

conf.env.append_unique('LINKFLAGS', '--as-needed')

node/tools/wafadmin/Tools/ccroot.py at master · elarkin/node · GitHub

Repository navigation

Expand file tree

Breadcrumbs

ccroot.py

Latest commit

History

Breadcrumbs

ccroot.py

File metadata and controls