ceph/src/boost/tools/build/src/tools/qt4.jam

   1 # Copyright 2002-2006 Vladimir Prus
   2 # Copyright 2005 Alo Sarv
   3 # Copyright 2005-2009 Juergen Hunold
   4 #
   5 # Distributed under the Boost Software License, Version 1.0. (See
   6 # accompanying file LICENSE_1_0.txt or copy at
   7 # http://www.boost.org/LICENSE_1_0.txt)
   8
   9 # Qt4 library support module
  10 #
  11 # The module attempts to auto-detect QT installation location from QTDIR
  12 # environment variable; failing that, installation location can be passed as
  13 # argument:
  14 #
  15 # toolset.using qt4 : /usr/local/Trolltech/Qt-4.0.0 ;
  16 #
  17 # The module supports code generation from .ui and .qrc files, as well as
  18 # running the moc preprocessor on headers. Note that you must list all your
  19 # moc-able headers in sources.
  20 #
  21 # Example:
  22 #
  23 #     exe myapp : myapp.cpp myapp.h myapp.ui myapp.qrc
  24 #                 /qt4//QtGui /qt4//QtNetwork ;
  25 #
  26 # It's also possible to run moc on cpp sources:
  27 #
  28 #   import cast ;
  29 #
  30 #   exe myapp : myapp.cpp [ cast _ moccable-cpp : myapp.cpp ] /qt4//QtGui ;
  31 #
  32 # When moccing source file myapp.cpp you need to include "myapp.moc" from
  33 # myapp.cpp. When moccing .h files, the output of moc will be automatically
  34 # compiled and linked in, you don't need any includes.
  35 #
  36 # This is consistent with Qt guidelines:
  37 # http://qt-project.org/doc/qt-4.8/moc.html
  38 #
  39 # The .qrc processing utility supports various command line option (see
  40 # http://qt-project.org/doc/qt-4.8/rcc.html for a complete list). The
  41 # module provides default arguments for the "output file" and
  42 # "initialization function name" options. Other options can be set through
  43 # the <rccflags> build property. E.g. if you wish the compression settings
  44 # to be more aggressive than the defaults, you can apply them too all .qrc
  45 # files like this:
  46 #
  47 #   project my-qt-project :
  48 #               requirements
  49 #               <rccflags>"-compress 9 -threshold 10"
  50 #           ;
  51 #
  52 # Of course, this property can also be specified on individual targets.
  53
  54
  55 import modules ;
  56 import feature ;
  57 import errors ;
  58 import type ;
  59 import "class" : new ;
  60 import generators ;
  61 import project ;
  62 import toolset : flags ;
  63 import os ;
  64 import virtual-target ;
  65 import scanner ;
  66
  67 # Qt3Support control feature
  68 #
  69 # Qt4 configure defaults to build Qt4 libraries with Qt3Support.
  70 # The autodetection is missing, so we default to disable Qt3Support.
  71 # This prevents the user from inadvertedly using a deprecated API.
  72 #
  73 # The Qt3Support library can be activated by adding
  74 # "<qt3support>on" to requirements
  75 #
  76 # Use "<qt3support>on:<define>QT3_SUPPORT_WARNINGS"
  77 # to get warnings about deprecated Qt3 support funtions and classes.
  78 # Files ported by the "qt3to4" conversion tool contain _tons_ of
  79 # warnings, so this define is not set as default.
  80 #
  81 # Todo: Detect Qt3Support from Qt's configure data.
  82 #       Or add more auto-configuration (like python).
  83 feature.feature qt3support : off on : propagated link-incompatible ;
  84
  85 # The Qt version used for requirements
  86 # Valid are <qt>4.4 or <qt>4.5.0
  87 # Auto-detection via qmake sets '<qt>major.minor.patch'
  88 feature.feature qt : : propagated ;
  89
  90 # Extra flags for rcc
  91 feature.feature rccflags : : free ;
  92
  93 project.initialize $(__name__) ;
  94 project qt ;
  95
  96 # Save the project so that we tolerate 'import + using' combo.
  97 .project = [ project.current ] ;
  98
  99 # Helper utils for easy debug output
 100 if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]
 101 {
 102     .debug-configuration = TRUE ;
 103 }
 104
 105 local rule debug-message ( message * )
 106 {
 107     if $(.debug-configuration) = TRUE
 108     {
 109         ECHO notice: [qt4-cfg] $(message) ;
 110     }
 111 }
 112
 113 # Capture qmake output line by line
 114 local rule read-output ( content )
 115 {
 116     local lines ;
 117     local nl = "
 118 " ;
 119     local << = "([^$(nl)]*)[$(nl)](.*)" ;
 120     local line+ = [ MATCH "$(<<)" : "$(content)" ] ;
 121     while $(line+)
 122     {
 123         lines += $(line+[1]) ;
 124         line+ = [ MATCH "$(<<)" : "$(line+[2])" ] ;
 125     }
 126     return $(lines) ;
 127 }
 128
 129 # Capture Qt version from qmake
 130 local rule check-version ( bin_prefix )
 131 {
 132     full-cmd = $(bin_prefix)"/qmake -v" ;
 133     debug-message Running '$(full-cmd)' ;
 134     local output = [ SHELL $(full-cmd) ] ;
 135     for line in [ read-output $(output) ]
 136     {
 137         # Parse the output to get all the results.
 138         if [ MATCH "QMake" : $(line) ]
 139         {
 140             # Skip first line of output
 141         }
 142         else
 143         {
 144             temp = [ MATCH "([0-9]*)\\.([0-9]*)\\.([0-9]*)" : $(line) ] ;
 145         }
 146     }
 147     return $(temp) ;
 148 }
 149
 150 # Validate the version string and extract the major/minor part we care about.
 151 #
 152 local rule split-version ( version )
 153 {
 154     local major-minor = [ MATCH ^([0-9]+)\.([0-9]+)(.*)$ : $(version) : 1 2 3 ] ;
 155     if ! $(major-minor[2]) || $(major-minor[3])
 156     {
 157         ECHO "Warning: 'using qt' expects a two part (major, minor) version number; got" $(version) instead ;
 158
 159         # Add a zero to account for the missing digit if necessary.
 160         major-minor += 0 ;
 161     }
 162
 163     return $(major-minor[1]) $(major-minor[2]) ;
 164 }
 165
 166 # Initialize the QT support module.
 167 # Parameters:
 168 # - 'prefix'    parameter tells where Qt is installed.
 169 # - 'full_bin'  optional full path to Qt binaries (qmake,moc,uic,rcc)
 170 # - 'full_inc'  optional full path to Qt top-level include directory
 171 # - 'full_lib'  optional full path to Qt library directory
 172 # - 'version'   optional version of Qt, else autodetected via 'qmake -v'
 173 # - 'condition' optional requirements
 174 rule init ( prefix : full_bin ? : full_inc ? : full_lib ? : version ? : condition * )
 175 {
 176     project.push-current $(.project) ;
 177
 178     debug-message "==== Configuring Qt ... ====" ;
 179     for local v in version cmd-or-prefix includes libraries condition
 180     {
 181         if $($(v))
 182         {
 183             debug-message "  user-specified "$(v): '$($(v))' ;
 184         }
 185     }
 186
 187     # Needed as default value
 188     .prefix = $(prefix) ;
 189
 190     # pre-build paths to detect reinitializations changes
 191     local inc_prefix lib_prefix bin_prefix ;
 192     if $(full_inc)
 193     {
 194         inc_prefix = $(full_inc) ;
 195     }
 196     else
 197     {
 198         inc_prefix = $(prefix)/include ;
 199     }
 200     if $(full_lib)
 201     {
 202         lib_prefix = $(full_lib) ;
 203     }
 204     else
 205     {
 206         lib_prefix = $(prefix)/lib ;
 207     }
 208     if $(full_bin)
 209     {
 210         bin_prefix = $(full_bin) ;
 211     }
 212     else
 213     {
 214         bin_prefix = $(prefix)/bin ;
 215     }
 216
 217     # Globally needed variables
 218     .incprefix = $(inc_prefix) ;
 219     .libprefix = $(lib_prefix) ;
 220     .binprefix = $(bin_prefix) ;
 221
 222     if ! $(.initialized)
 223     {
 224         # Make sure this is initialised only once
 225         .initialized = true ;
 226
 227         # Generates cpp files from header files using "moc" tool
 228         generators.register-standard qt4.moc : H : CPP(moc_%) : <allow>qt4 ;
 229
 230         # The OBJ result type is a fake, 'H' will be really produced. See
 231         # comments on the generator class, defined below the 'init' function.
 232         generators.register [ new uic-generator qt4.uic : UI : OBJ :
 233             <allow>qt4  ] ;
 234
 235         # The OBJ result type is a fake here too.
 236         generators.register [ new moc-h-generator
 237             qt4.moc.inc : MOCCABLE_CPP : OBJ : <allow>qt4 ] ;
 238
 239         generators.register [ new moc-inc-generator
 240             qt4.moc.inc : MOCCABLE_H : OBJ : <allow>qt4 ] ;
 241
 242         # Generates .cpp files from .qrc files.
 243         generators.register-standard qt4.rcc : QRC : CPP(qrc_%) : <allow>qt4 ;
 244
 245         # dependency scanner for wrapped files.
 246         type.set-scanner QRC : qrc-scanner ;
 247
 248         # Save value of first occuring prefix
 249         .PREFIX = $(prefix) ;
 250     }
 251
 252     if $(version)
 253     {
 254         major-minor = [ split-version $(version) ] ;
 255         version = $(major-minor:J=.) ;
 256     }
 257     else
 258     {
 259         version = [ check-version $(bin_prefix) ] ;
 260         if $(version)
 261         {
 262             version = $(version:J=.) ;
 263         }
 264         debug-message Detected version '$(version)' ;
 265     }
 266
 267     local target-requirements = $(condition) ;
 268
 269     # Add the version, if any, to the target requirements.
 270     if $(version)
 271     {
 272         if ! $(version) in [ feature.values qt ]
 273         {
 274             feature.extend qt : $(version) ;
 275         }
 276         target-requirements += <qt>$(version:E=default) ;
 277     }
 278
 279     local target-os = [ feature.get-values target-os : $(condition) ] ;
 280     if ! $(target-os)
 281     {
 282         target-os ?= [ feature.defaults target-os ] ;
 283         target-os = $(target-os:G=) ;
 284         target-requirements += <target-os>$(target-os) ;
 285     }
 286
 287     # Build exact requirements for the tools
 288     local tools-requirements = $(target-requirements:J=/) ;
 289
 290     debug-message "Details of this Qt configuration:" ;
 291     debug-message "  prefix:      " '$(prefix:E=<empty>)' ;
 292     debug-message "  binary path: " '$(bin_prefix:E=<empty>)' ;
 293     debug-message "  include path:" '$(inc_prefix:E=<empty>)' ;
 294     debug-message "  library path:" '$(lib_prefix:E=<empty>)' ;
 295     debug-message "  target requirements:" '$(target-requirements)' ;
 296     debug-message "  tool requirements:  " '$(tools-requirements)' ;
 297
 298     # setup the paths for the tools
 299     toolset.flags qt4.moc .BINPREFIX $(tools-requirements) : $(bin_prefix) ;
 300     toolset.flags qt4.rcc .BINPREFIX $(tools-requirements) : $(bin_prefix) ;
 301     toolset.flags qt4.uic .BINPREFIX $(tools-requirements) : $(bin_prefix) ;
 302
 303     # TODO: 2009-02-12: Better support for directories
 304     # Most likely needed are separate getters for: include,libraries,binaries and sources.
 305     toolset.flags qt4.directory .PREFIX $(tools-requirements) : $(prefix) ;
 306
 307     # Test for a buildable Qt.
 308     if [ glob $(.prefix)/Jamroot ]
 309     {
 310        .bjam-qt = true
 311
 312        # this will declare QtCore (and qtmain on <target-os>windows)
 313        add-shared-library QtCore ;
 314    }
 315    else
 316    # Setup common pre-built Qt.
 317    # Special setup for QtCore on which everything depends
 318    {
 319        local link = [ feature.get-values link : $(condition) ] ;
 320
 321        local usage-requirements =
 322            <include>$(.incprefix)
 323            <library-path>$(.libprefix)
 324            <threading>multi
 325            <allow>qt4 ;
 326
 327        if $(link) in shared
 328        {
 329            usage-requirements += <dll-path>$(.libprefix) ;
 330        }
 331
 332        local suffix ;
 333
 334        # Since Qt-4.2, debug versions on unix have to be built
 335        # separately and therefore have no suffix.
 336        .suffix_version = "" ;
 337        .suffix_debug = "" ;
 338
 339        # Control flag for auto-configuration of the debug libraries.
 340        # This setup requires Qt 'configure -debug-and-release'.
 341        # Only available on some platforms.
 342        # ToDo: 2009-02-12: Maybe throw this away and
 343        # require separate setup with <variant>debug as condition.
 344        .have_separate_debug = FALSE ;
 345
 346        # Setup other platforms
 347        if $(target-os) in windows cygwin
 348        {
 349            .have_separate_debug = TRUE ;
 350
 351            # On NT, the shared libs have "4" suffix, and "d" suffix in debug builds.
 352            if $(link) in shared
 353            {
 354                 .suffix_version = "4" ;
 355            }
 356            .suffix_debug = "d" ;
 357
 358            # On Windows we must link against the qtmain library
 359            lib qtmain
 360                : # sources
 361                : # requirements
 362                   <name>qtmain$(.suffix_debug)
 363                   <variant>debug
 364                   $(target-requirements)
 365                ;
 366
 367            lib qtmain
 368                : # sources
 369                : # requirements
 370                    <name>qtmain
 371                    $(target-requirements)
 372                ;
 373        }
 374        else if $(target-os) = darwin
 375        {
 376            # On MacOS X, both debug and release libraries are available.
 377            .suffix_debug = "_debug" ;
 378
 379            .have_separate_debug = TRUE ;
 380
 381            alias qtmain ;
 382        }
 383        else
 384        {
 385            alias qtmain : : $(target-requirements) ;
 386        }
 387
 388        lib QtCore : qtmain
 389            : # requirements
 390              <name>QtCore$(.suffix_version)
 391              $(target-requirements)
 392            : # default-build
 393            : # usage-requirements
 394              <define>QT_CORE_LIB
 395              <define>QT_NO_DEBUG
 396              <include>$(.incprefix)/QtCore
 397              $(usage-requirements)
 398            ;
 399
 400        if $(.have_separate_debug) = TRUE
 401        {
 402            debug-message Configure debug libraries with suffix '$(.suffix_debug)' ;
 403
 404            lib QtCore : $(main)
 405                : # requirements
 406                  <name>QtCore$(.suffix_debug)$(.suffix_version)
 407                  <variant>debug
 408                  $(target-requirements)
 409                : # default-build
 410                : # usage-requirements
 411                  <define>QT_CORE_LIB
 412                  <include>$(.incprefix)/QtCore
 413                  $(usage-requirements)
 414                ;
 415         }
 416     }
 417
 418     # Initialising the remaining libraries is canonical
 419     # parameters 'module' : 'depends-on' : 'usage-define' : 'requirements' : 'include'
 420     # 'include' only for non-canonical include paths.
 421     add-shared-library QtGui     : QtCore : QT_GUI_LIB     : $(target-requirements) ;
 422     add-shared-library QtNetwork : QtCore : QT_NETWORK_LIB : $(target-requirements) ;
 423     add-shared-library QtSql     : QtCore : QT_SQL_LIB     : $(target-requirements) ;
 424     add-shared-library QtXml     : QtCore : QT_XML_LIB     : $(target-requirements) ;
 425
 426     add-shared-library Qt3Support : QtGui QtNetwork QtXml QtSql
 427                                   : QT_QT3SUPPORT_LIB QT3_SUPPORT
 428                                   : <qt3support>on $(target-requirements) ;
 429
 430     # Dummy target to enable "<qt3support>off" and
 431     # "<library>/qt//Qt3Support" at the same time. This enables quick
 432     # switching from one to the other for test/porting purposes.
 433     alias Qt3Support : : <qt3support>off $(target-requirements) ;
 434
 435     # OpenGl Support
 436     add-shared-library QtOpenGL : QtGui : QT_OPENGL_LIB : $(target-requirements) ;
 437
 438     # SVG-Support (Qt 4.1)
 439     add-shared-library QtSvg : QtXml QtOpenGL : QT_SVG_LIB : $(target-requirements) ;
 440
 441     # Test-Support (Qt 4.1)
 442     add-shared-library QtTest : QtCore : : $(target-requirements) ;
 443
 444     # Qt designer library
 445     add-shared-library QtDesigner : QtGui QtXml : : $(target-requirements) ;
 446     add-shared-library QtDesignerComponents : QtGui QtXml : : $(target-requirements) ;
 447
 448     # Support for dynamic Widgets (Qt 4.1)
 449     add-static-library  QtUiTools : QtGui QtXml : $(target-requirements) ;
 450
 451     # DBus-Support (Qt 4.2)
 452     add-shared-library QtDBus : QtXml : : $(target-requirements) ;
 453
 454     # Script-Engine (Qt 4.3)
 455     add-shared-library QtScript : QtGui QtXml : QT_SCRIPT_LIB : $(target-requirements) ;
 456
 457     # Tools for the Script-Engine (Qt 4.5)
 458     add-shared-library QtScriptTools : QtScript : QT_SCRIPTTOOLS_LIB : $(target-requirements) ;
 459
 460     # WebKit (Qt 4.4)
 461     add-shared-library QtWebKit : QtGui : QT_WEBKIT_LIB : $(target-requirements) ;
 462
 463     # Phonon Multimedia (Qt 4.4)
 464     add-shared-library phonon : QtGui QtXml : QT_PHONON_LIB : $(target-requirements) ;
 465
 466     # Multimedia engine (Qt 4.6)
 467     add-shared-library QtMultimedia : QtGui : QT_MULTIMEDIA_LIB : $(target-requirements) ;
 468
 469     # XmlPatterns-Engine (Qt 4.4)
 470     add-shared-library QtXmlPatterns : QtNetwork : QT_XMLPATTERNS_LIB : $(target-requirements) ;
 471
 472     # Help-Engine (Qt 4.4)
 473     add-shared-library QtHelp    : QtGui QtSql QtXml : : $(target-requirements) ;
 474     add-shared-library QtCLucene : QCore QtSql QtXml : : $(target-requirements) ;
 475
 476     # QML-Engine (Qt 4.7)
 477     add-shared-library QtDeclarative : QtGui QtXml : : $(target-requirements) ;
 478
 479     # AssistantClient Support
 480     # Compat library removed in 4.7.0
 481     # Pre-4.4 help system, use QtHelp for new programs
 482     if $(version) < "4.7"
 483     {
 484        add-shared-library QtAssistantClient : QtGui : : $(target-requirements) : QtAssistant ;
 485     }
 486     debug-message "==== Configured Qt-$(version) ====" ;
 487
 488     project.pop-current ;
 489 }
 490
 491 rule initialized ( )
 492 {
 493     return $(.initialized) ;
 494 }
 495
 496
 497
 498 # This custom generator is needed because in QT4, UI files are translated only
 499 # into H files, and no C++ files are created. Further, the H files need not be
 500 # passed via MOC. The header is used only via inclusion. If we define a standard
 501 # UI -> H generator, Boost.Build will run MOC on H, and then compile the
 502 # resulting cpp. It will give a warning, since output from moc will be empty.
 503 #
 504 # This generator is declared with a UI -> OBJ signature, so it gets invoked when
 505 # linking generator tries to convert sources to OBJ, but it produces target of
 506 # type H. This is non-standard, but allowed. That header won't be mocced.
 507 #
 508 class uic-generator : generator
 509 {
 510     rule __init__ ( * : * )
 511     {
 512         generator.__init__ $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
 513     }
 514
 515     rule run ( project name ? : property-set : sources * )
 516     {
 517         if ! $(name)
 518         {
 519             name = [ $(sources[0]).name ] ;
 520             name = $(name:B) ;
 521         }
 522
 523         local a = [ new action $(sources[1]) : qt4.uic : $(property-set) ] ;
 524
 525         # The 'ui_' prefix is to match qmake's default behavior.
 526         local target = [ new file-target ui_$(name) : H : $(project) : $(a) ] ;
 527
 528         local r = [ virtual-target.register $(target) ] ;
 529
 530         # Since this generator will return a H target, the linking generator
 531         # won't use it at all, and won't set any dependency on it. However, we
 532         # need the target to be seen by bjam, so that dependency from sources to
 533         # this generated header is detected -- if jam does not know about this
 534         # target, it won't do anything.
 535         DEPENDS all : [ $(r).actualize ] ;
 536
 537         return $(r) ;
 538     }
 539 }
 540
 541
 542 class moc-h-generator : generator
 543 {
 544     rule __init__ ( * : * )
 545     {
 546         generator.__init__ $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
 547     }
 548
 549     rule run ( project name ? : property-set : sources * )
 550     {
 551         if ! $(sources[2]) && [ $(sources[1]).type ] = MOCCABLE_CPP
 552         {
 553             name = [ $(sources[0]).name ] ;
 554             name = $(name:B) ;
 555
 556             local a = [ new action $(sources[1]) : qt4.moc.inc :
 557                 $(property-set) ] ;
 558
 559             local target = [ new file-target $(name) : MOC : $(project) : $(a)
 560                 ] ;
 561
 562             local r = [ virtual-target.register $(target) ] ;
 563
 564             # Since this generator will return a H target, the linking generator
 565             # won't use it at all, and won't set any dependency on it. However,
 566             # we need the target to be seen by bjam, so that dependency from
 567             # sources to this generated header is detected -- if jam does not
 568             # know about this target, it won't do anything.
 569             DEPENDS all : [ $(r).actualize ] ;
 570
 571             return $(r) ;
 572         }
 573     }
 574 }
 575
 576
 577 class moc-inc-generator : generator
 578 {
 579     rule __init__ ( * : * )
 580     {
 581         generator.__init__ $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
 582     }
 583
 584     rule run ( project name ? : property-set : sources * )
 585     {
 586         if ! $(sources[2]) && [ $(sources[1]).type ] = MOCCABLE_H
 587         {
 588             name = [ $(sources[0]).name ] ;
 589             name = $(name:B) ;
 590
 591             local a = [ new action $(sources[1]) : qt4.moc.inc :
 592                 $(property-set) ] ;
 593
 594             local target = [ new file-target moc_$(name) : CPP : $(project) :
 595                 $(a) ] ;
 596
 597             # Since this generator will return a H target, the linking generator
 598             # won't use it at all, and won't set any dependency on it. However,
 599             # we need the target to be seen by bjam, so that dependency from
 600             # sources to this generated header is detected -- if jam does not
 601             # know about this target, it won't do anything.
 602             DEPENDS all : [ $(target).actualize ] ;
 603
 604             return [ virtual-target.register $(target) ] ;
 605         }
 606     }
 607 }
 608
 609
 610 # Query the installation directory. This is needed in at least two scenarios.
 611 # First, when re-using sources from the Qt-Tree. Second, to "install" custom Qt
 612 # plugins to the Qt-Tree.
 613 #
 614 rule directory
 615 {
 616     return $(.PREFIX) ;
 617 }
 618
 619 # Add a shared Qt library.
 620 rule add-shared-library ( lib-name : depends-on * : usage-defines * : requirements * :  include ? )
 621 {
 622      add-library $(lib-name) : $(.suffix_version) : $(depends-on) : $(usage-defines) : $(requirements) : $(include) ;
 623 }
 624
 625 # Add a static Qt library.
 626 rule add-static-library ( lib-name : depends-on * : usage-defines * : requirements * : include ? )
 627 {
 628      add-library $(lib-name) : : $(depends-on) : $(usage-defines) : $(requirements) : $(include) ;
 629 }
 630
 631 # Add a Qt library.
 632 # Static libs are unversioned, whereas shared libs have the major number as suffix.
 633 # Creates both release and debug versions on platforms where both are enabled by Qt configure.
 634 # Flags:
 635 # - lib-name Qt library Name
 636 # - version  Qt major number used as shared library suffix (QtCore4.so)
 637 # - depends-on other Qt libraries
 638 # - usage-defines those are set by qmake, so set them when using this library
 639 # - requirements addional requirements
 640 # - include non-canonical include path. The canonical path is $(.incprefix)/$(lib-name).
 641 rule add-library ( lib-name : version ? : depends-on * : usage-defines * : requirements * : include ? )
 642 {
 643     if $(.bjam-qt)
 644     {
 645         # Import Qt module
 646         # Eveything will be setup there
 647         alias $(lib-name)
 648            : $(.prefix)//$(lib-name)
 649            :
 650            :
 651            : <allow>qt4 ;
 652     }
 653     else
 654     {
 655         local real_include ;
 656         real_include ?= $(include) ;
 657         real_include ?= $(lib-name) ;
 658
 659         lib $(lib-name)
 660            : # sources
 661              $(depends-on)
 662            : # requirements
 663              <name>$(lib-name)$(version)
 664              $(requirements)
 665            : # default-build
 666            : # usage-requirements
 667              <define>$(usage-defines)
 668              <include>$(.incprefix)/$(real_include)
 669            ;
 670
 671         if $(.have_separate_debug) = TRUE
 672         {
 673             lib $(lib-name)
 674                : # sources
 675                  $(depends-on)
 676                : # requirements
 677                  <name>$(lib-name)$(.suffix_debug)$(version)
 678                  $(requirements)
 679                  <variant>debug
 680                : # default-build
 681                : # usage-requirements
 682                  <define>$(usage-defines)
 683                  <include>$(.incprefix)/$(real_include)
 684                ;
 685         }
 686     }
 687
 688     # Make library explicit so that a simple <use>qt4 will not bring in everything.
 689     # And some components like QtDBus/Phonon may not be available on all platforms.
 690     explicit $(lib-name) ;
 691 }
 692
 693 # Use $(.BINPREFIX[-1]) for the paths as several tools-requirements can match.
 694 # The exact match is the last one.
 695
 696 # Get <include> and <defines> from current toolset.
 697 flags qt4.moc INCLUDES <include> ;
 698 flags qt4.moc DEFINES <define> ;
 699
 700 # need a newline for expansion of DEFINES and INCLUDES in the response file.
 701 .nl  = "
 702 " ;
 703
 704 # Processes headers to create Qt MetaObject information. Qt4-moc has its
 705 # c++-parser, so pass INCLUDES and DEFINES.
 706 # We use response file with one INCLUDE/DEFINE per line
 707 #
 708 actions moc
 709 {
 710     $(.BINPREFIX[-1])/moc -f $(>) -o $(<) @"@($(<).rsp:E=-D$(DEFINES)$(.nl) -I$(INCLUDES:T)$(.nl))"
 711 }
 712
 713 # When moccing files for include only, we don't need -f, otherwise the generated
 714 # code will include the .cpp and we'll get duplicated symbols.
 715 #
 716 actions moc.inc
 717 {
 718     $(.BINPREFIX[-1])/moc $(>) -o $(<) @"@($(<).rsp:E=-D$(DEFINES)$(.nl) -I$(INCLUDES:T)$(.nl))"
 719 }
 720
 721
 722 # Get extra options for RCC
 723 flags qt4.rcc RCC_OPTIONS <rccflags> ;
 724
 725 # Generates source files from resource files.
 726 #
 727 actions rcc
 728 {
 729     $(.BINPREFIX[-1])/rcc $(>) -name $(>:B) $(RCC_OPTIONS) -o $(<)
 730 }
 731
 732
 733 # Generates user-interface source from .ui files.
 734 #
 735 actions uic
 736 {
 737     $(.BINPREFIX[-1])/uic $(>) -o $(<)
 738 }
 739
 740
 741 # Scanner for .qrc files. Look for the CDATA section of the <file> tag. Ignore
 742 # the "alias" attribute. See http://doc.trolltech.com/qt/resources.html for
 743 # detailed documentation of the Qt Resource System.
 744 #
 745 class qrc-scanner : common-scanner
 746 {
 747     rule pattern ( )
 748     {
 749         return "<file.*>(.*)</file>" ;
 750     }
 751 }
 752
 753
 754 # Wrapped files are "included".
 755 scanner.register qrc-scanner : include ;