# Copyright 2005 Dave Abrahams
# Copyright 2003 Rene Rivera
# Copyright 2003, 2004, 2005 Vladimir Prus
# Copyright (c) 2020 Edward Diener
# Distributed under the Boost Software License, Version 1.0.
# (See accompanying file LICENSE.txt or https://www.bfgroup.xyz/b2/LICENSE.txt)

#| tag::doc[]

[[bbv2.reference.tools.compiler.borland]]
= Borland C++ Compiler

The `borland` module supports the 32-bit command line C++ compilers
running on Microsoft Windows. This is the bcc32 executable for all
versions of Borland C++ and C++ Builder, as well as the command line
compatible compiler bcc32c on later versions of C++ Builder.

The module is initialized using the following syntax:

----
using borland : [version] : [c++-compile-command] : [compiler options] ;
----

This statement may be repeated several times, if you want to configure
several versions of the compiler.

If the command is not specified, Boost.Build will search for a binary
named `bcc32` in PATH.

The following options can be provided, using
_`<option-name>option-value syntax`_:

`cflags`::
Specifies additional compiler flags that will be used when compiling C
sources.

`cxxflags`::
Specifies additional compiler flags that will be used when compiling C++
sources.

`compileflags`::
Specifies additional compiler flags that will be used when compiling both C
and C++ sources.

`linkflags`::
Specifies additional command line options that will be passed to the linker.

`user-interface`::
Specifies the user interface for applications. Valid choices are `console`
for a console applicatiuon and `gui` for a Windows application.

|# # end::doc[]

#  Support for the Borland's command line compiler

import property ;
import generators ;
import os ;
import toolset : flags ;
import feature : get-values ;
import type ;
import common ;
import version ;

feature.extend toolset : borland ;

rule init ( version ? : command * : options * )
{

    local condition = [ common.check-init-parameters borland :
        version $(version) ] ;

    local command = [ common.get-invocation-command borland : bcc32.exe
        : $(command) ] ;

    common.handle-options borland : $(condition) : $(command) : $(options) ;

    local just_bcc32 = [ MATCH ".*(bcc32)([^a-z0-9]|$)" : $(command:L) ] ;

    if $(command)
    {
        command = [ common.get-absolute-tool-path $(command[-1]) ] ;
    }
    root = $(command:D) ;

    flags borland.compile STDHDRS $(condition) : $(root)/include/ ;
    flags borland.link STDLIBPATH $(condition) : $(root)/lib ;
    flags borland.link RUN_PATH $(condition) : $(root)/bin ;
    flags borland .root $(condition) : $(root)/bin/ ;

    local jv ;

    if $(version)
        {
        jv = [ MATCH "^([0-9.]+)" : $(version) ] ;
        }
    if ! $(jv) || [ version.version-less [ version-split $(jv) ] : 6 30 ]
        {
        init-earlier-releases $(condition) ;
        }
    else
        {
        init-later-releases $(condition) ;
        }

    if $(just_bcc32) && ( $(just_bcc32[1]) = bcc32 )
        {
        flags borland.compile OPTIONS $(condition) : -g255 -Vx- -Ve- -b- ;
        }
}

# Splits a version in its form of n[.n][.n] into n n n etc.
#
local rule version-split ( v )
{
return [ SPLIT_BY_CHARACTERS $(v) : . ] ;
}

local rule init-earlier-releases ( condition )
{

# Deal with various runtime configs...

# This should be not for DLL
flags borland OPTIONS $(condition)/<user-interface>console : -tWC ;

# -tWR sets -tW as well, so we turn it off here and then turn it
# on again later if we need it:
flags borland OPTIONS $(condition)/<runtime-link>shared : -tWR -tWC ;

flags borland OPTIONS $(condition)/<main-target-type>LIB/<link>shared : -tWD ;
# Hmm.. not sure what's going on here.
flags borland OPTIONS $(condition) : -WM- ;
flags borland OPTIONS $(condition)/<threading>multi : -tWM ;

flags borland.link OPTIONS $(condition)/<link>shared : -tWD ;

}

local rule init-later-releases ( condition )
{

# Deal with various runtime configs...

# This should be not for DLL
flags borland OPTIONS $(condition)/<user-interface>console : -tC ;

flags borland OPTIONS $(condition)/<runtime-link>shared : -tR ;

flags borland OPTIONS $(condition)/<main-target-type>LIB/<link>shared : -tD ;
flags borland OPTIONS $(condition)/<main-target-type>EXE : -tC ;
flags borland OPTIONS $(condition)/<threading>multi : -tM ;

flags borland.link.dll OPTIONS $(condition)/<link>shared : -tD ;

}

# A borland-specific target type
type.register BORLAND.TDS : tds ;

# Declare generators

generators.register-linker borland.link : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB : EXE : <toolset>borland ;
generators.register-linker borland.link.dll : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB : SHARED_LIB IMPORT_LIB : <toolset>borland ;

generators.register-archiver borland.archive : OBJ : STATIC_LIB : <toolset>borland ;
generators.register-c-compiler borland.compile.c++ : CPP : OBJ : <toolset>borland ;
generators.register-c-compiler borland.compile.c : C : OBJ : <toolset>borland ;
generators.register-standard borland.asm : ASM : OBJ : <toolset>borland ;

# Declare flags

flags borland.compile OPTIONS <debug-symbols>on : -v ;
flags borland.link OPTIONS <debug-symbols>on : -v ;

flags borland.compile OPTIONS <optimization>off : -Od ;
flags borland.compile OPTIONS <optimization>speed : -O2 ;
flags borland.compile OPTIONS <optimization>space : -O1 ;

if $(.BORLAND_HAS_FIXED_INLINING_BUGS)
{
    flags borland CFLAGS <inlining>off : -vi- ;
    flags borland CFLAGS <inlining>on : -vi -w-inl ;
    flags borland CFLAGS <inlining>full : -vi -w-inl ;
}
else
{
    flags borland CFLAGS : -vi- ;
}

flags borland.compile OPTIONS <warnings>off : -w- ;
flags borland.compile OPTIONS <warnings>all : -w ;
flags borland.compile OPTIONS <warnings>extra : -w ;
flags borland.compile OPTIONS <warnings>pedantic : -w ;
flags borland.compile OPTIONS <warnings-as-errors>on : -w! ;

flags borland OPTIONS <user-interface>gui : -tW ;

flags borland.compile OPTIONS <cflags> ;
flags borland.compile.c++ OPTIONS <cxxflags> ;
flags borland.compile DEFINES <define> ;
flags borland.compile INCLUDES <include> ;

flags borland NEED_IMPLIB <main-target-type>LIB/<link>shared : "" ;

#
# for C++ compiles the following options are turned on by default:
#
# -j5    stops after 5 errors
# -g255  allow an unlimited number of warnings
# -q     no banner
# -c     compile to object
# -P     C++ code regardless of file extension
# -a8    8 byte alignment, this option is on in the IDE by default
#        and effects binary compatibility.
#

# -U$(UNDEFS) -D$(DEFINES) $(CFLAGS) $(C++FLAGS) -I"$(HDRS)"  -I"$(STDHDRS)" -o"$(<)" "$(>)"


actions compile.c++
{
    "$(CONFIG_COMMAND)" -j5 -q -c -P -a8 $(OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -I"$(STDHDRS)" -o"$(<)" "$(>)"
}

# For C, we don't pass -P flag
actions compile.c
{
    "$(CONFIG_COMMAND)" -j5 -q -c -a8 $(OPTIONS) -D$(DEFINES) -I"$(INCLUDES)" -I"$(STDHDRS)" -o"$(<)" "$(>)"
}


# Declare flags and action for linking
flags borland.link OPTIONS <debug-symbols>on : -v ;
flags borland.link LIBRARY_PATH <library-path> ;
flags borland.link FINDLIBS_ST <find-static-library> ;
flags borland.link FINDLIBS_SA <find-shared-library> ;
flags borland.link LIBRARIES <library-file> ;

flags borland.link OPTIONS <linkflags> ;

flags borland.link LIBRARY_PATH_OPTION <toolset>borland : -L : unchecked ;
flags borland.link LIBRARY_OPTION <toolset>borland : "" : unchecked ;



# bcc32 needs to have ilink32 in the path in order to invoke it, so explicitly
# specifying $(BCC_TOOL_PATH)bcc32 doesn't help. You need to add
# $(BCC_TOOL_PATH) to the path
# The NEED_IMPLIB variable controls whether we need to invoke implib.

flags borland.archive AROPTIONS <archiveflags> ;

# Declare action for archives. We don't use response file
# since it's hard to get "+-" there.
# The /P256 increases 'page' size -- with too low
# values tlib fails when building large applications.
# CONSIDER: don't know what 'together' is for...
actions updated together piecemeal archive
{
    $(.set-path)$(.root:W)$(.old-path)
    tlib $(AROPTIONS) /P256 /u /a /C "$(<:W)" +-"$(>:W)"
}


if [ os.name ] = CYGWIN
{
    .set-path = "cmd /S /C set \"PATH=" ;
    .old-path = ";%PATH%\" \"&&\"" ;


    # Couldn't get TLIB to stop being confused about pathnames
    # containing dashes (it seemed to treat them as option separators
    # when passed through from bash), so we explicitly write the
    # command into a .bat file and execute that.  TLIB is also finicky
    # about pathname style! Forward slashes, too, are treated as
    # options.
    actions updated together piecemeal archive
    {
       chdir $(<:D)
       echo +-$(>:BS) > $(<:BS).rsp
       $(.set-path)$(.root)$(.old-path) "tlib.exe" $(AROPTIONS) /P256 /C $(<:BS) @$(<:BS).rsp && $(RM) $(<:BS).rsp
    }
}
else if [ os.name ] = NT
{
    .set-path = "set \"PATH=" ;
    .old-path = ";%PATH%\"
      " ;
}
else
{
    .set-path = "PATH=\"" ;
    .old-path = "\":$PATH
      export PATH
      " ;
}

RM = [ common.rm-command ] ;

nl = "
" ;

actions link
{
    $(.set-path)$(.root:W)$(.old-path) "$(CONFIG_COMMAND)" -v -q $(OPTIONS) -L"$(LIBRARY_PATH:W)" -L"$(STDLIBPATH:W)" -e"$(<[1]:W)" @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)$(LIBRARIES) $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST:S=.lib)" $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA:S=.lib)")"
}


actions link.dll bind LIBRARIES RSP
{
    $(.set-path)$(.root:W)$(.old-path) "$(CONFIG_COMMAND)" -v -q $(OPTIONS) -L"$(LIBRARY_PATH:W)" -L"$(STDLIBPATH:W)" -e"$(<[1]:W)" @"@($(<[1]:W).rsp:E=$(nl)"$(>)" $(nl)$(LIBRARIES) $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_ST:S=.lib)" $(nl)"$(LIBRARY_OPTION)$(FINDLIBS_SA:S=.lib)")"  && "$(.root)implib" "$(<[2]:W)" "$(<[1]:W)"
}

# It seems impossible to specify output file with directory when compiling
# asm files using bcc32, so use tasm32 directly.
# /ml makes all symbol names case-sensitive
actions asm
{
    $(.set-path)$(.root:W)$(.old-path) tasm32.exe /ml "$(>)" "$(<)"
}