# Copyright Eric Niebler 2005. Use, modification, and distribution are
# subject to the Boost Software License, Version 1.0. (See accompanying
# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

import os ;
import common ;
import doxygen ;
import quickbook ;

#
# Accumulators docs are dependent upon
# 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.
#
make latex.check : : @check-latex ;
actions check-latex
{
    latex -version > latex.version
}

make dvips.check : : @check-dvips ;
actions check-dvips
{
    dvips -version > dvips.version
}

make gs.check : : @check-gs ;

import os ;

if [ os.name ] = "NT"
{
   actions check-gs
   {
       gswin32c -version > gs.version
   }
}
else
{
   actions check-gs
   {
       gs -version > gs.version
   }
}

# Use Doxygen to emit a tagfile with the definition of depends_on<>. That
# tagfile will be used by Doxygen below when generating the Statistics Library
# Reference. This is all so that the Doxygen-generated documentation for the
# features shows the dependency relationships between them.
doxygen tagfile
    :
        ../../../boost/accumulators/framework/depends_on.hpp
        ../../../boost/accumulators/framework/extractor.hpp
    :
        <doxygen:param>MACRO_EXPANSION=YES
        <doxygen:param>EXPAND_ONLY_PREDEF=YES
        <doxygen:param>GENERATE_TAGFILE=accumulators.tag
        <doxygen:param>"PREDEFINED=\"BOOST_ACCUMULATORS_DOXYGEN_INVOKED=1\" \\
                                   \"BOOST_PP_REPEAT_FROM_TO(a,b,c,d)=\" \\
                                   \"BOOST_PP_ENUM_PARAMS(a,b)=b ## 1, b ## 2, ...\""
        <dependency>latex.check
        <dependency>dvips.check
        <dependency>gs.check
    ;

doxygen accdoc
    :
        [ glob ../../../boost/accumulators/accumulators*.hpp ]
        [ glob ../../../boost/accumulators/framework/*.hpp ]
        [ glob ../../../boost/accumulators/framework/parameters/*.hpp ]
        [ glob ../../../boost/accumulators/framework/accumulators/*.hpp ]
    :
        <doxygen:param>EXTRACT_ALL=YES
        <doxygen:param>"PREDEFINED=\"BOOST_ACCUMULATORS_DOXYGEN_INVOKED=1\" \\
                                   \"BOOST_PP_REPEAT_FROM_TO(a,b,c,d)=\" \\
                                   \"BOOST_PP_REPEAT(a,b,c)=\" \\
                                   \"BOOST_PARAMETER_KEYWORD(a,b)=\\
                                         namespace a { struct b {}; } \\
                                         boost::parameter::keyword<a::b> const b;\" \\
                                   \"BOOST_PP_ENUM_PARAMS(a,b)=b ## 1, b ## 2, ...\""
        <doxygen:param>HIDE_UNDOC_MEMBERS=NO
        <doxygen:param>EXTRACT_PRIVATE=NO
        <doxygen:param>ENABLE_PREPROCESSING=YES
        <doxygen:param>MACRO_EXPANSION=YES
        <doxygen:param>EXPAND_ONLY_PREDEF=YES
        <doxygen:param>SEARCH_INCLUDES=NO
        <reftitle>"Accumulators Framework Reference"
        <dependency>latex.check
        <dependency>dvips.check
        <dependency>gs.check
    ;

# Generate the HTML form of the stats documentation, as this causes Doxygen to
# generate .png images for the LaTeX formulas embedded in the doc comments.
doxygen statsdoc.html
    :
        [ glob ../../../boost/accumulators/statistics*.hpp ]
        [ glob ../../../boost/accumulators/statistics/*.hpp ]
        [ glob ../../../boost/accumulators/statistics/variates/*.hpp ]
    :
        <dependency>latex.check
        <dependency>dvips.check
        <dependency>gs.check
    ;

if [ os.name ] = NT
{
    CP = copy /y ;
    MKDIR = mkdir ;
    FROM = \\..\\..\\..\\html\\statsdoc\\*.png ;
    TOHTML = .\\html\\images\\accumulators ;
    TOPDF = \\images\\accumulators ;
}
else
{
    CP = cp ;
    MKDIR = mkdir -p ;
    FROM = /../../html/statsdoc/*.png ;
    TOHTML = ./html/images/accumulators ;
    TOPDF = /images/accumulators ;
}

actions copy-latex-pngs
{
    $(MKDIR) $(TOHTML)
    $(MKDIR) $(<:D)$(TOPDF)
    $(CP) $(<:D)$(FROM) $(TOHTML)
    $(CP) $(<:D)$(FROM) $(<:D)$(TOPDF)
    echo "Stamped" > "$(<)"
}

# This causes the png files built above to be copied into the
# html/images/accumulators directory.
make statsdoclatex.tag
    : statsdoc.html
    : @copy-latex-pngs
    ;

doxygen statsdoc
    :
        [ glob ../../../boost/accumulators/statistics*.hpp ]
        [ glob ../../../boost/accumulators/statistics/*.hpp ]
        [ glob ../../../boost/accumulators/statistics/variates/*.hpp ]
    :
        <doxygen:param>EXTRACT_ALL=YES
        <doxygen:param>"PREDEFINED=\"BOOST_ACCUMULATORS_DOXYGEN_INVOKED=1\" \\
                                   \"BOOST_PP_REPEAT_FROM_TO(a,b,c,d)=\" \\
                                   \"BOOST_PP_REPEAT(a,b,c)=\" \\
                                   \"BOOST_PARAMETER_KEYWORD(a,b)=\\
                                         namespace a { struct b {}; } \\
                                         boost::parameter::keyword<a::b> const b;\" \\
                                   \"BOOST_PP_ENUM_PARAMS(a,b)=b ## 1, b ## 2, ...\""
        <doxygen:param>HIDE_UNDOC_MEMBERS=NO
        <doxygen:param>EXTRACT_PRIVATE=NO
        <doxygen:param>ENABLE_PREPROCESSING=YES
        <doxygen:param>MACRO_EXPANSION=YES
        <doxygen:param>EXPAND_ONLY_PREDEF=YES
        <doxygen:param>SEARCH_INCLUDES=NO
        <doxygen:param>TAGFILES=accumulators.tag
        <xsl:param>boost.doxygen.formuladir=images/accumulators/
        <reftitle>"Statistics Library Reference"
        <dependency>tagfile
        <dependency>statsdoclatex.tag
        <dependency>latex.check
        <dependency>dvips.check
        <dependency>gs.check
    ;

doxygen opdoc
    :
        [ glob ../../../boost/accumulators/numeric/functional.hpp ]
        [ glob ../../../boost/accumulators/numeric/functional/*.hpp ]
    :
        <doxygen:param>EXTRACT_ALL=YES
        <doxygen:param>"PREDEFINED=\"BOOST_NUMERIC_FUNCTIONAL_DOXYGEN_INVOKED=1\" \\
                                   \"BOOST_NUMERIC_FUNCTIONAL_DEFINE_BINARY_OP(a,b,c)=\\
                                         namespace functional { \\
                                         template<class Left,class Right,class EnableIf=void> struct a ## _base \\
                                         : std::binary_function<Left, Right, typeof(lvalue<Left>() b lvalue<Right>())> { \\
                                         /** \\return left b right */ \\
                                         result_type operator()(Left &left, Right &right) const; }; \\
                                         template<class Left,class Right, \\
                                                  class LeftTag=typename tag<Left>::type, \\
                                                  class RightTag=typename tag<Right>::type> \\
                                         struct a : a ## _base<Left,Right,void> {}; } \\
                                         namespace op { \\
                                         struct a : boost::detail::function2< \\
                                             functional::a<_1,_2,functional::tag<_1>,functional::tag<_2> > > {}; } \\
                                         namespace { \\
                                         /** \\return functional::a<Left, Right>()(left, right) */ \\
                                         op::a const & a = boost::detail::pod_singleton<op::min_assign>::instance; } \" \\
                                   \"BOOST_NUMERIC_FUNCTIONAL_DEFINE_UNARY_OP(a,b)=\\
                                         namespace functional { \\
                                         template<class Arg,class EnableIf=void> struct a ## _base \\
                                         : std::unary_function<Arg, typeof(b lvalue<Arg>())> { \\
                                         /** \\return b arg */ \\
                                         result_type operator()(Arg & arg) const; }; \\
                                         template<class Arg,class Tag=typename tag<Arg>::type> \\
                                         struct a : a ## _base<Arg,void> {}; } \\
                                         namespace op { \\
                                         struct a : boost::detail::function1< \\
                                             functional::a<_,functional::tag<_> > > {}; } \\
                                         namespace { \\
                                         /** \\return functional::a<Arg>()(arg) */ \\
                                         op::a const & a = boost::detail::pod_singleton<op::min_assign>::instance; }\""
        <doxygen:param>HIDE_UNDOC_MEMBERS=NO
        <doxygen:param>EXTRACT_PRIVATE=NO
        <doxygen:param>ENABLE_PREPROCESSING=YES
        <doxygen:param>MACRO_EXPANSION=YES
        <doxygen:param>EXPAND_ONLY_PREDEF=YES
        <doxygen:param>SEARCH_INCLUDES=NO
        <reftitle>"Numeric Operators Library Reference"
        <dependency>latex.check
        <dependency>dvips.check
        <dependency>gs.check
    ;

xml accumulators
    :
        accumulators.qbk
    :
        <xsl:param>boost.max.id.length=1024
        <xsl:param>toc.max.depth=4
        <xsl:param>toc.section.depth=4
        <xsl:param>chunk.section.depth=2
    ;

path-constant images_location : html ;

boostbook standalone
    :
        accumulators
    :
        <xsl:param>boost.root=../../../..
        <xsl:param>boost.max.id.length=1024
        <xsl:param>toc.max.depth=4
        <xsl:param>toc.section.depth=4
        <xsl:param>chunk.section.depth=2
        <dependency>accdoc
        <dependency>statsdoc
        <dependency>opdoc
        <format>pdf:<xsl:param>img.src.path=$(images_location)/
        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
    ;

###############################################################################
alias boostdoc
    : accumulators
    :
    : <dependency>accdoc <dependency>statsdoc <dependency>opdoc
    : ;
explicit boostdoc ;
alias boostrelease ;
explicit boostrelease ;