yuzu/externals/vcpkg/packages/boost-build_x64-windows/tools/boost-build/Jamroot.jam

# Copyright 2019 Rene Rivera
# Copyright 2017 Steven Watanabe
# Copyright 2016 Vladimir Prus
# Copyright 2017 Edward Diener
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE.txt or https://www.bfgroup.xyz/b2/LICENSE.txt)

import "class" : new ;
import bison ;
import errors ;
import feature ;
import indirect ;
import os ;
# import package ;
import path ;
import set ;
import stage : add-install-dir ;
import toolset ;
import type ;
import virtual-target ;

path-constant SELF : . ;

project b2
    : build-dir .build
    : requirements
        <cxxstd>11
        <toolset>msvc:<define>_CRT_SECURE_NO_WARNINGS=1
        <toolset>msvc:<define>_CRT_NONSTDC_NO_DEPRECATE=1
    ;

#|
Build the engine and its dependencies outside of the simple core build scripts.
This allows us to keep the core build scripts as simple as possible. And lets
us support more functionality for development of the engine core.
|#

#|
Define custom yyacc tool.
|#

feature.feature yyacc : : dependency free ;
toolset.flags yyacc TOOL <yyacc> ;

exe yyacc
    :   src/engine/yyacc.cpp
    :   ;
explicit yyacc ;

rule yyacc-gen ( project name : property-set : sources * )
{
    local relevant = [ toolset.relevant $(__name__).yyacc ] ;
    local a = [ new action $(sources[1]) : $(__name__).yyacc : [ $(property-set).add $(relevant) ] ] ;
    local targets ;
    for local n in $(name:S=).y $(name:S=)tab.h
    {
        targets += [ virtual-target.register
            [ new file-target $(n) exact : [ type.type $(n) ]
                : $(project) : $(a)
                ] ] ;
    }
    return $(targets) ;
}

actions yyacc bind TOOL
{
    "$(TOOL)" "$(<)" "$(>)"
}

generate jamgram.y
    :   src/engine/jamgram.yy
    :   <generating-rule>@yyacc-gen
        <location>src/engine
        <yyacc>yyacc <dependency>yyacc
    ;
explicit jamgram.y ;

#|
Define grammar translation with Bison.
|#

BISON = [ os.environ BISON ] ;
BISON ?= bison ;
local BISON_IN_PATH = [ path.glob [ os.executable-path ] : $(BISON[1]) $(BISON[1]).* ] ;

rule grammar ( target : source : properties * )
{
    # LOCATE on $(target) = $(source:D) ;
    BISON on $(target) = $(BISON) ;
}

actions grammar
{
    "$(BISON)" --yacc --defines -o "$(<[1])" "$(>)"
}

if $(BISON_IN_PATH)
{
    make jamgram.cpp
        :   src/engine/jamgram.y
        :   @grammar
        :   <dependency>jamgram.y
            <location>src/engine ;
}
else
{
    errors.warning "Bison generator program '$(BISON:J= )' not found. Skipping grammar build." ;
    alias jamgram.cpp
        :   src/engine/jamgram.cpp ;
}
explicit jamgram.cpp ;

#|
Define the b2 executable. Sources are based on platform.
TODO: Make platform specific source be no-ops when not needed.
|#

local python-exe = [ MATCH --with-python=(.*) : [ modules.peek : ARGV ] ] ;
local python-include ;
local python-ldlib ;
if $(python-exe)
{
    python-include = [ SHELL
        "$(python-exe) -c \"import sysconfig; print(sysconfig.get_path('include'));\""
        : strip-eol ] ;
    python-libdir = [ SHELL
        "$(python-exe) -c \"import sysconfig; import os.path; print(sysconfig.get_config_var('LIBDIR'));\""
        : strip-eol ] ;
    python-ldlib = [ MATCH ".*(python.*)" : [ SHELL
        "$(python-exe) -c \"import sysconfig; import os.path; print(sysconfig.get_config_var('LIBRARY'));\""
        : strip-eol ] ] ;
    python-ldlib = $(python-ldlib:S=) ;

    lib python
        :
        : <name>$(python-ldlib) <search>$(python-libdir)
        :
        : <include>$(python-include) <define>HAVE_PYTHON ;
}
else
{
    alias python ;
}

obj jamgram.obj
    :   jamgram.cpp
    :   <toolset>gcc:<cxxflags>-Wno-free-nonheap-object
    ;
explicit jamgram.obj ;

local b2_src =
    [ glob src/engine/*.cpp src/engine/modules/*.cpp :
        src/engine/*nt.cpp src/engine/*unix.cpp src/engine/*vms.cpp
        src/engine/yyacc.cpp src/engine/mkjambase.cpp
        src/engine/check_*.cpp
        src/engine/jamgram.cpp
        ] ;
local b2_src_nt = [ glob src/engine/*nt.cpp ] ;
local b2_src_unix = [ glob src/engine/*unix.cpp ] ;
local b2_src_vms = [ glob src/engine/*vms.cpp ] ;
local unix_os = [ set.difference [ feature.values <target-os> ] : windows vms ] ;

exe b2
    :   $(b2_src)
        jamgram.obj
        python
    :   <target-os>windows:<source>$(b2_src_nt)
        <target-os>vms:<source>$(b2_src_vms)
        <target-os>$(unix_os):<source>$(b2_src_unix)
        <toolset>msvc:<find-static-library>kernel32
        <toolset>msvc:<find-static-library>advapi32
        <toolset>msvc:<find-static-library>user32
    ;
explicit b2 ;

#|
Installation of the engine, build, and example files.
|#

feature.feature b2-install-layout : standard portable : incidental propagated ;

add-install-dir b2prefix-standard : : prefix ;
add-install-dir b2bindir-standard : : bindir ;
add-install-dir b2coredir-standard : boost-build/src : datarootdir ;
add-install-dir b2examplesdir-standard : boost-build/examples : datarootdir ;

add-install-dir b2prefix-portable : : prefix ;
add-install-dir b2bindir-portable : : b2prefix-portable ;
add-install-dir b2coredir-portable : .b2 : b2prefix-portable ;
add-install-dir b2examplesdir-portable : .b2/examples : b2prefix-portable ;

local ext = "" ;
if [ os.on-windows ] || [ os.on-vms ]
{
    ext = ".exe" ;
}

install b2-engine
    :   $(SELF)/src/engine/b2$(ext)
    :   <b2-install-layout>standard:<location>(b2bindir-standard)
        <b2-install-layout>portable:<location>(b2bindir-portable)
    ;
explicit b2-engine ;

local examples ;
for local e in [ glob-tree-ex $(SELF)/example : * : . .svn ]
{
    if [ CHECK_IF_FILE [ path.native $(e) ] ]
    {
        examples += $(e) ;
    }
}
install b2-examples
    : # What to install
        $(examples)
    :   # What is the root of the directory
        <install-source-root>example
        # Which subdir of $prefix/share
        <b2-install-layout>standard:<location>(b2examplesdir-standard)
        <b2-install-layout>portable:<location>(b2examplesdir-portable)
    ;
explicit b2-examples ;

local .core-sources =
    $(SELF)/src/build-system.jam
    [ path.glob-tree $(SELF)/src/build : *.jam ]
    [ path.glob-tree $(SELF)/src/contrib : *.jam ]
    [ path.glob-tree $(SELF)/src/kernel : *.jam ]
    [ path.glob-tree $(SELF)/src/options : *.jam ]
    [ path.glob-tree $(SELF)/src/util : *.jam ]
    [ path.glob-tree $(SELF)/src/tools : *.jam *.xml *.xsl *.doxyfile *.hpp doxproc.py ]
    ;
if $(python-exe)
{
    .core-sources +=
        [ path.glob-tree $(SELF)/src/build : *.py ]
        [ path.glob-tree $(SELF)/src/contrib : *.py ]
        [ path.glob-tree $(SELF)/src/kernel : *.py ]
        [ path.glob-tree $(SELF)/src/options : *.py ]
        [ path.glob-tree $(SELF)/src/util : *.py ]
        [ path.glob-tree $(SELF)/src/tools : *.py : doxproc.py ]
        ;
}

install b2-core
    :   # What to install
        $(.core-sources)
    :   # What is the root of the directory
        <install-source-root>src
        # Which subdir of $prefix/share
        <b2-install-layout>standard:<location>(b2coredir-standard)
        <b2-install-layout>portable:<location>(b2coredir-portable)
    ;
explicit b2-core ;

#|
Only install example files when requested to avoid bloating install footprint.
|#
if --with-examples in [ modules.peek : ARGV ]
{
    alias install : b2-engine b2-core b2-examples ;
}
else
{
    alias install : b2-engine b2-core ;
}
explicit install ;