Jamroot

# Copyright 2004-2008 Spencer Olson

echo " Physical constants library:  " ;
echo "---------------" ;
echo " In bjam, there are two ways to import/use this library." ;
echo " 1.  /physical//physical" ;
echo "     This provides includes for only the headers of this library." ;
echo " 2.  /physical//calc" ;
echo "     This provides includes for the headers, linkage to the bison/flex" ;
echo "     based calculator library, dependency on boost_regex, and" ;
echo "     a header-library dependency on boost_math (used to " ;
echo "     define some trig functions on std::complex<> that are" ;
echo "     going to be included in the new standard, but are not" ;
echo "     yet available)" ;
echo "---------------" ;
echo "            Possible compile/feature options" ;
echo "              <phys-type>" ;
echo "                Purpose:  Specify the basic type used by the physical library." ;
echo "                values:" ;
echo "                    complex [default] (std::complex<double>)" ;
echo "                    cfloat            (std::complex<float>)" ;
echo "                    double            (double)" ;
echo "                    float             (float)" ;
echo "          To select these features for building add them to the bjam command such as:" ;
echo "          'bjam phys-type=cfloat'" ;
echo "---------------" ;
echo "" ;

# Usage:
#
#   bjam [options] [properties] [install|stage]
#
#   Builds and installs physical.
#
# Targets and Related Options:
#
#   install                 Install headers and compiled library files to the
#   =======                 configured locations (below).
#
#   --prefix=<PREFIX>       Install architecture independent files here.
#                           Default; C:\physical on Win32
#                           Default; /usr/local on Unix. Linux, etc.
#
#   --exec-prefix=<EPREFIX> Install architecture dependent files here.
#                           Default; <PREFIX>
#
#   --libdir=<DIR>          Install library files here.
#                           Default; <EPREFIX>/lib
#
#   --includedir=<HDRDIR>   Install header files here.
#                           Default; <PREFIX>/include
#
#   stage                   Build and install only compiled library files
#   =====                   to the ./stage directory.
#
# Other Options:
#
#   --build-dir=DIR         Build in this location instead of building
#                           within the distribution tree. Recommended!
#
#   --help                  This message.
#
# Properties:
#
#   toolset=toolset         Indicates the toolset to build with.
#
#   variant=debug|release   Select the build variant
#
#   link=static|shared      Whether to build static or shared libraries
#
#   threading=single|multi  Whether to build single or multithreaded binaries
# 
#   runtime-link=static|shared      
#                           Whether to link to static or shared C and C++ runtime.
#   

import feature : feature ;
import path ; # for getting a better glob
import package ; # used for installing whole package (provides --prefix related
                 # options )
import common : find-tool ;
import numbers : less ;


path-constant TOP : . ;

constant VERSION : [ SHELL "printf `cd $(TOP); git describe 2> /dev/null` || printf physical-0.1.3 " ] ;

# root-project loads boost and others...
use-project /root-project : ../ ;

project /physical
    : requirements
        <include>cxx
        <library>/boost//headers
        <define>PHYSICAL_VERSION=\\\"$(VERSION)\\\"
    : usage-requirements
        <include>cxx
        <library>/boost//headers
        <define>PHYSICAL_VERSION=\\\"$(VERSION)\\\"
    ;


# a rule for checking the version of a particular tool
# minimum-version  : e.g. "2.4.2"  (double quotese appear to be required
# additional-paths : other places to search for the tool (besides $PATH)
# path-last        : search $PATH after $(additional-paths) [Default false]
rule check-version ( name : minimum-version : version-opt ? :
                     additional-paths * : path-last ? ) {
    local tool = [ find-tool $(name) $(additional-paths) $(path-last) ] ;
    local vopt ;
    if $(version-opt) {
        vopt = $(version-opt) ;
    } else {
        vopt = "--version" ;
    }
    if $(tool) {
        local tversion = [ MATCH "([0-9.]+)" : [ SHELL "$(tool) $(vopt)" ] ] ;
        local tmajor = [ MATCH "([0-9]+)" : "$(tversion)" ] ;
        local tminor = [ MATCH "[0-9]+\.([0-9]+)" : "$(tversion)" ] ;
        local tpatch = [ MATCH "[0-9]+\.[0-9]+\.([0-9]+)" : "$(tversion)" ] ;
        tmajor ?= "" ;
        tminor ?= "" ;
        tpatch ?= "" ;

        local mmajor = [ MATCH "([0-9]+)" : "$(minimum-version)" ] ;
        local mminor = [ MATCH "[0-9]+\.([0-9]+)" : "$(minimum-version)" ] ;
        local mpatch = [ MATCH "[0-9]+\.[0-9]+\.([0-9]+)" : "$(minimum-version)" ] ;
        mmajor ?= "" ;
        mminor ?= "" ;
        mpatch ?= "" ;

        if ( $(tversion) = $(minimum-version)  ||
             [ less $(mmajor) $(tmajor) ] ||
             ( $(mmajor) = $(tmajor) && [ less $(mminor) $(tminor) ] ) ||
             ( $(mmajor) = $(tmajor) && $(mminor) = $(tminor) &&
               [ less $(mpatch) $(tpatch) ] ) ) {
            return $(tversion) ;
        }
    }
}

local ParserYY ;
local YY_include ;
if [ check-version "bison" : "2.4" ] {
    import bison ;
    ParserYY = cxx/physical/calc/detail/Parser.yy ;
} else {
    echo "Compatible version of GNU bison not found.  Using pre-generated parser" ;
    ParserYY = cxx/physical/calc/detail/pregen-parser/Parser.cpp ;
    YY_include = <include>cxx/physical/calc/detail/pregen-parser ;
}

local ScannerLL ;
local LL_include ;
if [ check-version "flex" : "2.5.35" ] {
    import lex ;
    ScannerLL = cxx/physical/calc/detail/Scanner.ll ;
} else {
    echo "Compatible version of GNU flex not found.  Using pre-generated lexer" ;
    ScannerLL = cxx/physical/calc/detail/pregen-scanner/Scanner.cpp ;
    LL_include = <include>cxx/physical/calc/detail/pregen-scanner ;
}


lib physical
    : # sources
      cxx/physical/system.cpp
      physical_runtime_constants
      [ glob cxx/physical/*.h ]
      [ glob cxx/physical/calc/*.h ]
    : <link>static
    : # no default build
    : # no includes
    ;

obj physical_runtime_constants
    : cxx/physical/runtime.cpp
    : <target-os>cygwin:<optimization>off
    ;

lib calc
    : Driver
      Parser
      Scanner
    : <link>static
      <use>physical
      <use>/boost//regex/<link>static
    : # no default build
    : <library>physical
      <library>/boost//regex/<link>static
      <include>$(project).build-dir
    ;

# the driver, scanner, and parser have a particular dependency graph
obj Driver
    : cxx/physical/calc/Driver.cpp
    : <implicit-dependency>Scanner
      <implicit-dependency>Parser
    ;

obj Scanner
    : $(ScannerLL)
    : $(LL_include)
      <implicit-dependency>Parser
    : # no default build
    : # usage requirements
      $(LL_include)
    ;

obj Parser
    : $(ParserYY)
    : $(YY_include)
      $(LL_include)
    : # no default build
    : # usage requirements
      $(YY_include)
    ;

feature phys-type : complex cfloat double float : composite ;
feature.compose <phys-type>complex : <define>RUNTIME_PHYSICAL_QUANTITY=\"std::complex<double>\" ;
feature.compose <phys-type>cfloat : <define>RUNTIME_PHYSICAL_QUANTITY=\"std::complex<float>\" ;
feature.compose <phys-type>double : <define>RUNTIME_PHYSICAL_QUANTITY=double ;
feature.compose <phys-type>float : <define>RUNTIME_PHYSICAL_QUANTITY=float ;


# installation configuration

# options:
install-properties =
    <install-no-version-symlinks>on
    ;

if [ modules.peek : NT ] {
    install-properties += <install-default-prefix>C:/physical ;
} else if [ modules.peek : UNIX ] {
    install-properties += <install-default-prefix>/usr/local ;
}


# the list of libraries to build and install
local libraries = physical ;
# all headers to install
local all_headers = [ path.glob-tree cxx : *.h *.cpp : .svn ] ;
# docs to install
local docs = [ path.glob-tree docs/api/html docs/api/latex : * : .svn ] ;


# Complete install allowing --prefix and related command line options
alias install : install-code install-docs ;
explicit install ;

# Complete install allowing --prefix and related command line options
package.install install-code
    : $(install-properties)
      <install-source-root>$(TOP)/cxx
    :
    : $(libraries)
    : $(all_headers)
    ;
explicit install-code ;

# install data allowing --prefix and related command line options
package.install install-docs
    : $(install-properties)
      <install-source-root>$(TOP)
      <install-header-subdir>../share/physical
    :
    :
    : $(docs)
    ;
explicit install-docs ;


# install the libs into a staging dir
install stage : $(libraries) ;
explicit stage ;