| # Copyright 2003, 2004 Douglas Gregor |
| # Copyright 2003, 2004, 2005 Vladimir Prus |
| # Copyright 2006 Rene Rivera |
| # Distributed under the Boost Software License, Version 1.0. |
| # (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) |
| |
| # This module defines rules to handle generation of various outputs from source |
| # files documented with doxygen comments. The supported transformations are: |
| # |
| # * Source -> Doxygen XML -> BoostBook XML |
| # * Source -> Doxygen HTML |
| # |
| # The type of transformation is selected based on the target requested. For |
| # BoostBook XML, the default, specifying a target with an ".xml" suffix, or an |
| # empty suffix, will produce a <target>.xml and <target>.boostbook. For Doxygen |
| # HTML specifying a target with an ".html" suffix will produce a directory |
| # <target> with the Doxygen html files, and a <target>.html file redirecting to |
| # that directory. |
| |
| import "class" : new ; |
| import targets ; |
| import feature ; |
| import property ; |
| import generators ; |
| import boostbook ; |
| import type ; |
| import path ; |
| import print ; |
| import regex ; |
| import stage ; |
| import project ; |
| import xsltproc ; |
| import make ; |
| import os ; |
| import toolset : flags ; |
| import alias ; |
| import common ; |
| import modules ; |
| import project ; |
| import utility ; |
| |
| |
| # Use to specify extra configuration paramters. These get translated |
| # into a doxyfile which configures the building of the docs. |
| feature.feature doxygen:param : : free ; |
| |
| # Specify the "<xsl:param>boost.doxygen.header.prefix" XSLT option. |
| feature.feature prefix : : free ; |
| |
| # Specify the "<xsl:param>boost.doxygen.reftitle" XSLT option. |
| feature.feature reftitle : : free ; |
| |
| # Which processor to use for various translations from Doxygen. |
| feature.feature doxygen.processor : xsltproc doxproc : propagated implicit ; |
| |
| # To generate, or not, index sections. |
| feature.feature doxygen.doxproc.index : no yes : propagated incidental ; |
| |
| # The ID for the resulting BoostBook reference section. |
| feature.feature doxygen.doxproc.id : : free ; |
| |
| # The title for the resulting BoostBook reference section. |
| feature.feature doxygen.doxproc.title : : free ; |
| |
| # Location for images when generating XML |
| feature.feature doxygen:xml-imagedir : : free ; |
| |
| # Indicates whether the entire directory should be deleted |
| feature.feature doxygen.rmdir : off on : optional incidental ; |
| |
| # Doxygen configuration input file. |
| type.register DOXYFILE : doxyfile ; |
| |
| # Doxygen XML multi-file output. |
| type.register DOXYGEN_XML_MULTIFILE : xml-dir : XML ; |
| |
| # Doxygen XML coallesed output. |
| type.register DOXYGEN_XML : doxygen : XML ; |
| |
| # Doxygen HTML multifile directory. |
| type.register DOXYGEN_HTML_MULTIFILE : html-dir : HTML ; |
| |
| # Redirection HTML file to HTML multifile directory. |
| type.register DOXYGEN_HTML : : HTML ; |
| |
| type.register DOXYGEN_XML_IMAGES : doxygen-xml-images ; |
| |
| # Initialize the Doxygen module. Parameters are: |
| # name: the name of the 'doxygen' executable. If not specified, the name |
| # 'doxygen' will be used |
| # |
| rule init ( name ? ) |
| { |
| if ! $(.initialized) |
| { |
| .initialized = true ; |
| |
| if ! $(name) |
| { |
| local doxygen-path ; |
| |
| if [ os.name ] = NT |
| { |
| local ProgramFiles = [ modules.peek : ProgramFiles ] ; |
| if $(ProgramFiles) |
| { |
| ProgramFiles = "$(ProgramFiles:J= )" ; |
| } |
| else |
| { |
| ProgramFiles = "C:\\Program Files" ; |
| } |
| |
| doxygen-path = |
| [ GLOB |
| [ modules.peek : PATH ] |
| "$(ProgramFiles)\\doxygen\\bin" |
| : doxygen\.exe ] ; |
| } |
| else |
| { |
| doxygen-path = |
| [ GLOB |
| [ modules.peek : PATH ] |
| : doxygen ] ; |
| } |
| |
| doxygen-path = $(doxygen-path[1]) ; |
| |
| if $(doxygen-path) |
| { |
| .doxygen = $(doxygen-path) ; |
| } |
| |
| .doxygen ?= doxygen ; |
| } |
| else |
| { |
| .doxygen = $(name) ; |
| } |
| |
| if --debug-configuration in [ modules.peek : ARGV ] |
| { |
| ECHO "notice:" using doxygen ":" $(.doxygen) ; |
| } |
| |
| if [ .is-cygwin ] |
| { |
| .is-cygwin = true ; |
| } |
| |
| .doxproc = [ modules.binding $(__name__) ] ; |
| .doxproc = $(.doxproc:D)/doxproc.py ; |
| |
| generators.register-composing doxygen.headers-to-doxyfile |
| : H HPP CPP : DOXYFILE ; |
| generators.register-standard doxygen.run |
| : DOXYFILE : DOXYGEN_XML_MULTIFILE ; |
| generators.register-standard doxygen.xml-dir-to-boostbook |
| : DOXYGEN_XML_MULTIFILE : BOOSTBOOK : <doxygen.processor>doxproc ; |
| generators.register-standard doxygen.xml-to-boostbook |
| : DOXYGEN_XML : BOOSTBOOK : <doxygen.processor>xsltproc ; |
| generators.register-standard doxygen.collect |
| : DOXYGEN_XML_MULTIFILE : DOXYGEN_XML ; |
| generators.register-standard doxygen.run |
| : DOXYFILE : DOXYGEN_HTML_MULTIFILE ; |
| generators.register-standard doxygen.html-redirect |
| : DOXYGEN_HTML_MULTIFILE : DOXYGEN_HTML ; |
| generators.register-standard doxygen.copy-latex-pngs |
| : DOXYGEN_HTML : DOXYGEN_XML_IMAGES ; |
| |
| IMPORT $(__name__) : doxygen : : doxygen ; |
| } |
| } |
| |
| |
| rule name ( ) |
| { |
| return $(.doxygen) ; |
| } |
| |
| rule .is-cygwin ( ) |
| { |
| if [ os.on-windows ] |
| { |
| local file = [ path.make [ modules.binding $(__name__) ] ] ; |
| local dir = [ path.native |
| [ path.join [ path.parent $(file) ] doxygen ] ] ; |
| local command = |
| "cd \"$(dir)\" && \"$(.doxygen)\" windows-paths-check.doxyfile 2>&1" ; |
| result = [ SHELL $(command) ] ; |
| if [ MATCH "(Parsing file /)" : $(result) ] |
| { |
| return true ; |
| } |
| } |
| } |
| |
| # Runs Doxygen on the given Doxygen configuration file (the source) to generate |
| # the Doxygen files. The output is dumped according to the settings in the |
| # Doxygen configuration file, not according to the target! Because of this, we |
| # essentially "touch" the target file, in effect making it look like we have |
| # really written something useful to it. Anyone that uses this action must deal |
| # with this behavior. |
| # |
| actions doxygen-action |
| { |
| $(RM) "$(*.XML)" & "$(NAME:E=doxygen)" "$(>)" && echo "Stamped" > "$(<)" |
| } |
| |
| |
| # Runs the Python doxproc XML processor. |
| # |
| actions doxproc |
| { |
| python "$(DOXPROC)" "--xmldir=$(>)" "--output=$(<)" "$(OPTIONS)" "--id=$(ID)" "--title=$(TITLE)" |
| } |
| |
| |
| rule translate-path ( path ) |
| { |
| if [ os.on-windows ] |
| { |
| if [ os.name ] = CYGWIN |
| { |
| if $(.is-cygwin) |
| { |
| return $(path) ; |
| } |
| else |
| { |
| return $(path:W) ; |
| } |
| } |
| else |
| { |
| if $(.is-cygwin) |
| { |
| match = [ MATCH ^(.):(.*) : $(path) ] ; |
| if $(match) |
| { |
| return /cygdrive/$(match[1])$(match[2]:T) ; |
| } |
| else |
| { |
| return $(path:T) ; |
| } |
| } |
| else |
| { |
| return $(path) ; |
| } |
| } |
| } |
| else |
| { |
| return $(path) ; |
| } |
| } |
| |
| |
| # Generates a doxygen configuration file (doxyfile) given a set of C++ sources |
| # and a property list that may contain <doxygen:param> features. |
| # |
| rule headers-to-doxyfile ( target : sources * : properties * ) |
| { |
| local text "# Generated by Boost.Build version 2" ; |
| |
| local output-dir ; |
| |
| # Translate <doxygen:param> into command line flags. |
| for local param in [ feature.get-values <doxygen:param> : $(properties) ] |
| { |
| local namevalue = [ regex.match ([^=]*)=(.*) : $(param) ] ; |
| if $(namevalue[1]) = OUTPUT_DIRECTORY |
| { |
| output-dir = [ translate-path |
| [ utility.unquote $(namevalue[2]) ] ] ; |
| text += "OUTPUT_DIRECTORY = \"$(output-dir)\"" ; |
| } |
| else |
| { |
| text += "$(namevalue[1]) = $(namevalue[2])" ; |
| } |
| } |
| |
| if ! $(output-dir) |
| { |
| output-dir = [ translate-path [ on $(target) return $(LOCATE) ] ] ; |
| text += "OUTPUT_DIRECTORY = \"$(output-dir)\"" ; |
| } |
| |
| local headers = ; |
| for local header in $(sources:G=) |
| { |
| header = [ translate-path $(header) ] ; |
| headers += \"$(header)\" ; |
| } |
| |
| # Doxygen generates LaTex by default. So disable it unconditionally, or at |
| # least until someone needs, and hence writes support for, LaTex output. |
| text += "GENERATE_LATEX = NO" ; |
| text += "INPUT = $(headers:J= )" ; |
| print.output $(target) plain ; |
| print.text $(text) : true ; |
| } |
| |
| |
| # Run Doxygen. See doxygen-action for a description of the strange properties of |
| # this rule. |
| # |
| rule run ( target : source : properties * ) |
| { |
| if <doxygen.rmdir>on in $(properties) |
| { |
| local output-dir = |
| [ path.make |
| [ MATCH <doxygen:param>OUTPUT_DIRECTORY=\"?([^\"]*) : |
| $(properties) ] ] ; |
| local html-dir = |
| [ path.make |
| [ MATCH <doxygen:param>HTML_OUTPUT=(.*) : |
| $(properties) ] ] ; |
| if $(output-dir) && $(html-dir) && |
| [ path.glob $(output-dir) : $(html-dir) ] |
| { |
| HTMLDIR on $(target) = |
| [ path.native [ path.join $(output-dir) $(html-dir) ] ] ; |
| rm-htmldir $(target) ; |
| } |
| } |
| doxygen-action $(target) : $(source) ; |
| NAME on $(target) = $(.doxygen) ; |
| RM on $(target) = [ modules.peek common : RM ] ; |
| *.XML on $(target) = |
| [ path.native |
| [ path.join |
| [ path.make [ on $(target) return $(LOCATE) ] ] |
| $(target:B:S=) |
| *.xml ] ] ; |
| } |
| |
| if [ os.name ] = NT |
| { |
| RMDIR = rmdir /s /q ; |
| } |
| else |
| { |
| RMDIR = rm -rf ; |
| } |
| |
| actions quietly rm-htmldir |
| { |
| $(RMDIR) $(HTMLDIR) |
| } |
| |
| # The rules below require Boost.Book stylesheets, so we need some code to check |
| # that the boostbook module has actualy been initialized. |
| # |
| rule check-boostbook ( ) |
| { |
| if ! [ modules.peek boostbook : .initialized ] |
| { |
| ECHO "error: the boostbook module is not initialized" ; |
| ECHO "error: you've attempted to use the 'doxygen' toolset, " ; |
| ECHO "error: which requires Boost.Book," ; |
| ECHO "error: but never initialized Boost.Book." ; |
| EXIT "error: Hint: add 'using boostbook ;' to your user-config.jam" ; |
| } |
| } |
| |
| |
| # Collect the set of Doxygen XML files into a single XML source file that can be |
| # handled by an XSLT processor. The source is completely ignored (see |
| # doxygen-action), because this action picks up the Doxygen XML index file |
| # xml/index.xml. This is because we can not teach Doxygen to act like a NORMAL |
| # program and take a "-o output.xml" argument (grrrr). The target of the |
| # collection will be a single Doxygen XML file. |
| # |
| rule collect ( target : source : properties * ) |
| { |
| check-boostbook ; |
| local collect-xsl-dir |
| = [ path.native [ path.join [ boostbook.xsl-dir ] doxygen collect ] ] ; |
| local source-path |
| = [ path.make [ on $(source) return $(LOCATE) ] ] ; |
| local collect-path |
| = [ path.root [ path.join $(source-path) $(source:B) ] [ path.pwd ] ] ; |
| local native-path |
| = [ path.native $(collect-path) ] ; |
| local real-source |
| = [ path.native [ path.join $(collect-path) index.xml ] ] ; |
| xsltproc.xslt $(target) : $(real-source) $(collect-xsl-dir:S=.xsl) |
| : <xsl:param>doxygen.xml.path=$(native-path) ; |
| } |
| |
| |
| # Translate Doxygen XML into BoostBook. |
| # |
| rule xml-to-boostbook ( target : source : properties * ) |
| { |
| check-boostbook ; |
| local xsl-dir = [ boostbook.xsl-dir ] ; |
| local d2b-xsl = [ path.native [ path.join [ boostbook.xsl-dir ] doxygen |
| doxygen2boostbook.xsl ] ] ; |
| |
| local xslt-properties = $(properties) ; |
| for local prefix in [ feature.get-values <prefix> : $(properties) ] |
| { |
| xslt-properties += "<xsl:param>boost.doxygen.header.prefix=$(prefix)" ; |
| } |
| for local title in [ feature.get-values <reftitle> : $(properties) ] |
| { |
| xslt-properties += "<xsl:param>boost.doxygen.reftitle=$(title)" ; |
| } |
| |
| xsltproc.xslt $(target) : $(source) $(d2b-xsl) : $(xslt-properties) ; |
| } |
| |
| |
| flags doxygen.xml-dir-to-boostbook OPTIONS <doxygen.doxproc.index>yes : --enable-index ; |
| flags doxygen.xml-dir-to-boostbook ID <doxygen.doxproc.id> ; |
| flags doxygen.xml-dir-to-boostbook TITLE <doxygen.doxproc.title> ; |
| |
| |
| rule xml-dir-to-boostbook ( target : source : properties * ) |
| { |
| DOXPROC on $(target) = $(.doxproc) ; |
| |
| LOCATE on $(source:S=) = [ on $(source) return $(LOCATE) ] ; |
| |
| doxygen.doxproc $(target) : $(source:S=) ; |
| } |
| |
| |
| # Generate the HTML redirect to HTML dir index.html file. |
| # |
| rule html-redirect ( target : source : properties * ) |
| { |
| local uri = "$(target:B)/index.html" ; |
| print.output $(target) plain ; |
| print.text |
| "<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" |
| \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\"> |
| <html xmlns=\"http://www.w3.org/1999/xhtml\"> |
| <head> |
| <meta http-equiv=\"refresh\" content=\"0; URL=$(uri)\" /> |
| |
| <title></title> |
| </head> |
| |
| <body> |
| Automatic redirection failed, please go to <a href= |
| \"$(uri)\">$(uri)</a>. |
| </body> |
| </html> |
| " |
| : true ; |
| } |
| |
| rule copy-latex-pngs ( target : source : requirements * ) |
| { |
| local directory = [ path.native |
| [ feature.get-values <doxygen:xml-imagedir> : |
| $(requirements) ] ] ; |
| |
| local location = [ on $(target) return $(LOCATE) ] ; |
| |
| local pdf-location = |
| [ path.native |
| [ path.join |
| [ path.make $(location) ] |
| [ path.make $(directory) ] ] ] ; |
| local html-location = |
| [ path.native |
| [ path.join |
| . |
| html |
| [ path.make $(directory) ] ] ] ; |
| |
| common.MkDir $(pdf-location) ; |
| common.MkDir $(html-location) ; |
| |
| DEPENDS $(target) : $(pdf-location) $(html-location) ; |
| |
| if [ os.name ] = NT |
| { |
| CP on $(target) = copy /y ; |
| FROM on $(target) = \\*.png ; |
| TOHTML on $(target) = .\\html\\$(directory) ; |
| TOPDF on $(target) = \\$(directory) ; |
| } |
| else |
| { |
| CP on $(target) = cp ; |
| FROM on $(target) = /*.png ; |
| TOHTML on $(target) = ./html/$(directory) ; |
| TOPDF on $(target) = $(target:D)/$(directory) ; |
| } |
| } |
| |
| actions copy-latex-pngs |
| { |
| $(CP) $(>:S=)$(FROM) $(TOHTML) |
| $(CP) $(>:S=)$(FROM) $(<:D)$(TOPDF) |
| echo "Stamped" > "$(<)" |
| } |
| |
| # building latex images for doxygen XML depends |
| # on latex, dvips, and ps being in your PATH. |
| # This is true for most Unix installs, but |
| # not on Win32, where you will need to install |
| # MkTex and Ghostscript and add these tools |
| # to your path. |
| |
| actions check-latex |
| { |
| latex -version >$(<) |
| } |
| |
| actions check-dvips |
| { |
| dvips -version >$(<) |
| } |
| |
| if [ os.name ] = "NT" |
| { |
| actions check-gs |
| { |
| gswin32c -version >$(<) |
| } |
| } |
| else |
| { |
| actions check-gs |
| { |
| gs -version >$(<) |
| } |
| } |
| |
| rule check-tools ( ) |
| { |
| if ! $(.check-tools-targets) |
| { |
| # Find the root project. |
| local root-project = [ project.current ] ; |
| root-project = [ $(root-project).project-module ] ; |
| while |
| [ project.attribute $(root-project) parent-module ] && |
| [ project.attribute $(root-project) parent-module ] != user-config |
| { |
| root-project = |
| [ project.attribute $(root-project) parent-module ] ; |
| } |
| |
| .latex.check = [ new file-target latex.check |
| : |
| : [ project.target $(root-project) ] |
| : [ new action : doxygen.check-latex ] |
| : |
| ] ; |
| .dvips.check = [ new file-target dvips.check |
| : |
| : [ project.target $(root-project) ] |
| : [ new action : doxygen.check-dvips ] |
| : |
| ] ; |
| .gs.check = [ new file-target gs.check |
| : |
| : [ project.target $(root-project) ] |
| : [ new action : doxygen.check-gs ] |
| : |
| ] ; |
| .check-tools-targets = $(.latex.check) $(.dvips.check) $(.gs.check) ; |
| } |
| return $(.check-tools-targets) ; |
| } |
| |
| project.initialize $(__name__) ; |
| project doxygen ; |
| |
| class doxygen-check-tools-target-class : basic-target |
| { |
| import doxygen ; |
| rule construct ( name : sources * : property-set ) |
| { |
| return [ property-set.empty ] [ doxygen.check-tools ] ; |
| } |
| } |
| |
| local project = [ project.current ] ; |
| |
| targets.main-target-alternative |
| [ new doxygen-check-tools-target-class check-tools : $(project) |
| : [ targets.main-target-sources : check-tools : no-renaming ] |
| : [ targets.main-target-requirements : $(project) ] |
| : [ targets.main-target-default-build : $(project) ] |
| : [ targets.main-target-usage-requirements : $(project) ] |
| ] ; |
| |
| # User-level rule to generate BoostBook XML from a set of headers via Doxygen. |
| # |
| rule doxygen ( target : sources * : requirements * : default-build * : usage-requirements * ) |
| { |
| local project = [ project.current ] ; |
| |
| if $(target:S) = .html |
| { |
| # Build an HTML directory from the sources. |
| local html-location = [ feature.get-values <location> : $(requirements) ] ; |
| local output-dir ; |
| if [ $(project).get build-dir ] |
| { |
| # Explicitly specified build dir. Add html at the end. |
| output-dir = [ path.join [ $(project).build-dir ] $(html-location:E=html) ] ; |
| } |
| else |
| { |
| # Trim 'bin' from implicit build dir, for no other reason that backward |
| # compatibility. |
| output-dir = [ path.join [ path.parent [ $(project).build-dir ] ] |
| $(html-location:E=html) ] ; |
| } |
| output-dir = [ path.root $(output-dir) [ path.pwd ] ] ; |
| local output-dir-native = [ path.native $(output-dir) ] ; |
| requirements = [ property.change $(requirements) : <location> ] ; |
| |
| ## The doxygen configuration file. |
| targets.main-target-alternative |
| [ new typed-target $(target:S=.tag) : $(project) : DOXYFILE |
| : [ targets.main-target-sources $(sources) : $(target:S=.tag) ] |
| : [ targets.main-target-requirements $(requirements) |
| <doxygen:param>GENERATE_HTML=YES |
| <doxygen:param>GENERATE_XML=NO |
| <doxygen:param>"OUTPUT_DIRECTORY=\"$(output-dir-native)\"" |
| <doxygen:param>HTML_OUTPUT=$(target:B) |
| : $(project) ] |
| : [ targets.main-target-default-build $(default-build) : $(project) ] |
| ] ; |
| $(project).mark-target-as-explicit $(target:S=.tag) ; |
| |
| ## The html directory to generate by running doxygen. |
| targets.main-target-alternative |
| [ new typed-target $(target:S=.dir) : $(project) : DOXYGEN_HTML_MULTIFILE |
| : $(target:S=.tag) |
| : [ targets.main-target-requirements $(requirements) |
| <doxygen:param>"OUTPUT_DIRECTORY=\"$(output-dir-native)\"" |
| <doxygen:param>HTML_OUTPUT=$(target:B) |
| : $(project) ] |
| : [ targets.main-target-default-build $(default-build) : $(project) ] |
| ] ; |
| $(project).mark-target-as-explicit $(target:S=.dir) ; |
| |
| ## The redirect html file into the generated html. |
| targets.main-target-alternative |
| [ new typed-target $(target) : $(project) : DOXYGEN_HTML |
| : $(target:S=.dir) |
| : [ targets.main-target-requirements $(requirements) |
| <location>$(output-dir) |
| : $(project) ] |
| : [ targets.main-target-default-build $(default-build) : $(project) ] |
| ] ; |
| } |
| else |
| { |
| # Build a BoostBook XML file from the sources. |
| local location-xml = [ feature.get-values <location> : $(requirements) ] ; |
| requirements = [ property.change $(requirements) : <location> ] ; |
| local target-xml = $(target:B=$(target:B)-xml) ; |
| |
| # Check whether we need to build images |
| local images-location = |
| [ feature.get-values <doxygen:xml-imagedir> : $(requirements) ] ; |
| if $(images-location) |
| { |
| doxygen $(target).doxygen-xml-images.html : $(sources) |
| : $(requirements) |
| <doxygen.rmdir>on |
| <doxygen:param>QUIET=YES |
| <doxygen:param>WARNINGS=NO |
| <doxygen:param>WARN_IF_UNDOCUMENTED=NO |
| <dependency>/doxygen//check-tools ; |
| $(project).mark-target-as-explicit |
| $(target).doxygen-xml-images.html ; |
| |
| targets.main-target-alternative |
| [ new typed-target $(target).doxygen-xml-images |
| : $(project) : DOXYGEN_XML_IMAGES |
| : $(target).doxygen-xml-images.html |
| : [ targets.main-target-requirements $(requirements) |
| : $(project) ] |
| : [ targets.main-target-default-build $(default-build) |
| : $(project) ] |
| ] ; |
| |
| $(project).mark-target-as-explicit |
| $(target).doxygen-xml-images ; |
| |
| if ! [ regex.match "^(.*/)$" : $(images-location) ] |
| { |
| images-location = $(images-location)/ ; |
| } |
| |
| requirements += |
| <dependency>$(target).doxygen-xml-images |
| <xsl:param>boost.doxygen.formuladir=$(images-location) ; |
| } |
| |
| ## The doxygen configuration file. |
| targets.main-target-alternative |
| [ new typed-target $(target-xml:S=.tag) : $(project) : DOXYFILE |
| : [ targets.main-target-sources $(sources) : $(target-xml:S=.tag) ] |
| : [ targets.main-target-requirements $(requirements) |
| <doxygen:param>GENERATE_HTML=NO |
| <doxygen:param>GENERATE_XML=YES |
| <doxygen:param>XML_OUTPUT=$(target-xml) |
| : $(project) ] |
| : [ targets.main-target-default-build $(default-build) : $(project) ] |
| ] ; |
| $(project).mark-target-as-explicit $(target-xml:S=.tag) ; |
| |
| ## The Doxygen XML directory of the processed source files. |
| targets.main-target-alternative |
| [ new typed-target $(target-xml:S=.dir) : $(project) : DOXYGEN_XML_MULTIFILE |
| : $(target-xml:S=.tag) |
| : [ targets.main-target-requirements $(requirements) |
| : $(project) ] |
| : [ targets.main-target-default-build $(default-build) : $(project) ] |
| ] ; |
| $(project).mark-target-as-explicit $(target-xml:S=.dir) ; |
| |
| ## The resulting BoostBook file is generated by the processor tool. The |
| ## tool can be either the xsltproc plus accompanying XSL scripts. Or it |
| ## can be the python doxproc.py script. |
| targets.main-target-alternative |
| [ new typed-target $(target-xml) : $(project) : BOOSTBOOK |
| : $(target-xml:S=.dir) |
| : [ targets.main-target-requirements $(requirements) |
| : $(project) ] |
| : [ targets.main-target-default-build $(default-build) : $(project) ] |
| ] ; |
| $(project).mark-target-as-explicit $(target-xml) ; |
| |
| targets.main-target-alternative |
| [ new install-target-class $(target:S=.xml) : $(project) |
| : $(target-xml) |
| : [ targets.main-target-requirements $(requirements) |
| <location>$(location-xml:E=.) |
| <name>$(target:S=.xml) |
| : $(project) ] |
| : [ targets.main-target-default-build $(default-build) : $(project) ] |
| ] ; |
| $(project).mark-target-as-explicit $(target:S=.xml) ; |
| |
| targets.main-target-alternative |
| [ new alias-target-class $(target) : $(project) |
| : |
| : [ targets.main-target-requirements $(requirements) |
| : $(project) ] |
| : [ targets.main-target-default-build $(default-build) : $(project) ] |
| : [ targets.main-target-usage-requirements $(usage-requirements) |
| <dependency>$(target:S=.xml) |
| : $(project) ] |
| ] ; |
| } |
| } |