Re: [Boost-users] OpenVMS 8.2 port?

From: Boris Gubenko (Boris.Gubenko_at_[hidden])
Date: 2005-11-27 16:14:46

In 2004, I was trying to build jam on VMS and discovered, that
build_vms.com script does not work. I fixed it and was able to
build bootstrap jam. I've attached modified build_vms.com to this
message.

However, like Philip A. Naecker, I could not use the bootstrap jam
to build jam, so, I gave up on the idea of using jam on VMS.

I just tried to build jam using build.jam you've attached to your mail
message, and it failed -- see below. The things I noticed: [.foo.c]
should have been []foo.c or just foo.c : on VMS, []foo.c is an
equivalent of ./foo.c on Unix. Also, the C (and C++) compiler on VMS
generates the .obj file vs. .o file on Unix. From the output below,
it seems to me, that build.jam expects .o.

In this quick experiment, I was using jam sources from 1.31.0
distribution (which was the released version of boost in April, 2004).
I can try it with the CVS HEAD if you think, that it can make a
difference (I doubt it).

Boris

$ cc/ver
HP C X7.1-367 on OpenVMS IA64 V8.2
$

$ @build_vms
Building bootstrap jam...
Cleaning any previous build...
...found 1 target...
...updating 1 target...
...updated 1 target...
Building Boost.Jam...
don't know how to make [.command.c]
don't know how to make [.compile.c]
don't know how to make [.expand.c]
don't know how to make [.glob.c]
don't know how to make [.hash.c]
don't know how to make [.hcache.c]
don't know how to make [.headers.c]
don't know how to make [.hdrmacro.c]
don't know how to make [.jam.c]
don't know how to make [.jambase.c]
don't know how to make [.jamgram.c]
don't know how to make [.lists.c]
don't know how to make [.make.c]
don't know how to make [.make1.c]
don't know how to make [.newstr.c]
don't know how to make [.option.c]
don't know how to make [.parse.c]
don't know how to make [.regexp.c]
don't know how to make [.rules.c]
don't know how to make [.scan.c]
don't know how to make [.search.c]
don't know how to make [.subst.c]
don't know how to make [.timestamp.c]
don't know how to make [.variable.c]
don't know how to make [.modules.c]
don't know how to make [.strings.c]
don't know how to make [.filesys.c]
don't know how to make [.builtins.c]
don't know how to make [.pwd.c]
don't know how to make [.class.c]
don't know how to make [.native.c]
don't know how to make [.modules/set.c]
don't know how to make [.modules/path.c]
don't know how to make [.modules/regex.c]
don't know how to make [.modules/property-set.c]
don't know how to make [.modules/sequence.c]
don't know how to make [.modules/order.c]
don't know how to make [.execvms.c]
don't know how to make [.filevms.c]
don't know how to make [.pathvms.c]
...found 83 targets...
...can't find 40 targets...
...can't make 41 targets...
...skipped command.o for lack of [.command.c]...
...skipped compile.o for lack of [.compile.c]...
...skipped expand.o for lack of [.expand.c]...
...skipped glob.o for lack of [.glob.c]...
...skipped hash.o for lack of [.hash.c]...
...skipped hcache.o for lack of [.hcache.c]...
...skipped headers.o for lack of [.headers.c]...
...skipped hdrmacro.o for lack of [.hdrmacro.c]...
...skipped jam.o for lack of [.jam.c]...
...skipped jambase.o for lack of [.jambase.c]...
...skipped jamgram.o for lack of [.jamgram.c]...
...skipped lists.o for lack of [.lists.c]...
...skipped make.o for lack of [.make.c]...
...skipped make1.o for lack of [.make1.c]...
...skipped newstr.o for lack of [.newstr.c]...
...skipped option.o for lack of [.option.c]...
...skipped parse.o for lack of [.parse.c]...
...skipped regexp.o for lack of [.regexp.c]...
...skipped rules.o for lack of [.rules.c]...
...skipped scan.o for lack of [.scan.c]...
...skipped search.o for lack of [.search.c]...
...skipped subst.o for lack of [.subst.c]...
...skipped timestamp.o for lack of [.timestamp.c]...
...skipped variable.o for lack of [.variable.c]...
...skipped modules.o for lack of [.modules.c]...
...skipped strings.o for lack of [.strings.c]...
...skipped filesys.o for lack of [.filesys.c]...
...skipped builtins.o for lack of [.builtins.c]...
...skipped pwd.o for lack of [.pwd.c]...
...skipped class.o for lack of [.class.c]...
...skipped native.o for lack of [.native.c]...
...skipped modules_set.o for lack of [.modules/set.c]...
...skipped modules_path.o for lack of [.modules/path.c]...
...skipped modules_regex.o for lack of [.modules/regex.c]...
...skipped modules_property-set.o for lack of [.modules/property-set.c]...
...skipped modules_sequence.o for lack of [.modules/sequence.c]...
...skipped modules_order.o for lack of [.modules/order.c]...
...skipped execvms.o for lack of [.execvms.c]...
...skipped filevms.o for lack of [.filevms.c]...
...skipped pathvms.o for lack of [.pathvms.c]...
...skipped bjam.exe for lack of command.o...
...skipped 41 targets...
$

$ mcr [.bootstrap_vms]jam0.exe -V
Boost.Jam  Version 3.1.9. OS=VMS.
   Copyright 1993-2002 Christopher Seiwald and Perforce Software, Inc.
   Copyright 2001 David Turner.
   Copyright 2001-2002 David Abrahams.
$

build_vms.com
-------------
$ ! Copyright (C) Rene Rivera, Johan Nilsson, 2002-2003.
$ !
$ ! 8-APR-2004  Boris Gubenko
$ ! Miscellaneous improvements.
$ !
$ ! Use, modification and distribution is subject to the
$ ! Boost Software License, Version 1.0. (See accompanying file
$ ! LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
$ !
$ ! bootstrap build script for Jam
$ !
$ callerverify = 'f$verify(0)
$ set = "set"
$ set symbol /verb/scope=(nolocal,noglobal)
$ on warning then continue
$ say := write sys$output
$ !
$ IF "" .NES. F$SEARCH("[.bootstrap_vms]*.*")
$ THEN
$   say "Cleaning previous boostrap files..."
$   SET FILE/PROTECTION=(W:RWED) [.bootstrap_vms]*.*;*
$   DELETE [.bootstrap_vms]*.*;*
$   say "Removing previous boostrap directory..."
$   SET FILE/PROT=(W:RWED) []bootstrap_vms.dir;1
$   DELETE []bootstrap_vms.dir;1
$   say "Creating boostrap directory..."
$   CREATE/DIR [.bootstrap_vms]
$ ENDIF
$ !
$ say "Building bootstrap jam..."
$ !
$ obj_directory = f$envi("default") - "]" + ".bootstrap_vms]"
$ CC_FLAGS = "/DEFINE=VMS/WARN=NOINFO/PREFIX=(ALL,EXCEPT=GLOB)" + -
             "/OBJ=''obj_directory'"
$ cc 'CC_FLAGS -
     builtins.c, -
     class.c, -
     command.c, -
     compile.c, -
     execvms.c, -
     expand.c, -
     filesys.c, -
     filevms.c, -
     glob.c, -
     hash.c, -
     hdrmacro.c, -
     headers.c, -
     jam.c, -
     jambase.c, -
     jamgram.c, -
     lists.c, -
     make.c, -
     make1.c, -
     modules.c, -
     native.c, -
     newstr.c, -
     option.c, -
     parse.c, -
     pathvms.c, -
     pwd.c, -
     regexp.c, -
     rules.c, -
     scan.c, -
     search.c, -
     strings.c, -
     subst.c, -
     timestamp.c, -
     variable.c
$ !
$ set def [.modules]
$ cc 'CC_FLAGS -
     path.c, -
     property-set.c, -
     regex.c, -
     sequence.c, -
     set.c
$ set def [-]
$ !
$ libr/create [.bootstrap_vms]libjam0.olb [.bootstrap_vms]*.obj
$ link/exec=[.bootstrap_vms]jam0.exe -
      [.bootstrap_vms]libjam0.olb/include=jam/lib
$ !
$ say "Cleaning any previous build..."
$ !
$ MCR [.bootstrap_vms]jam0.exe -f build.jam --toolset=vmsdecc clean
$ !
$ say "Building Boost.Jam..."
$ !
$ MCR [.bootstrap_vms]jam0.exe -f build.jam --toolset=vmsdecc
$ !
$ unused = f$verify(callerverify)
$ exit

----- Original Message ----- 
From: "Rene Rivera" <grafik.list_at_[hidden]>
To: <boost-users_at_[hidden]>
Sent: Sunday, November 27, 2005 2:14 PM
Subject: Re: [Boost-users] OpenVMS 8.2 port?

> Sorry it took me a while to get back to you, holidays and all that ;-)
>
> Philip A. Naecker wrote:
>> That was the clue I needed - that there are files in ./modules.  I was 
>> able
>> to build the bootstrap jam by hand.  Thanks.
>
> When you get a chance could you send me the changes you did to the
> build_vms.com so that I can integrate them into the next release.
>
>> But now when I try to build jam using the bootstrap jam, I get the errors
>> shown below.  I can't figure out the "don't know how to make modules/*.c"
>> errors.  The errors that look like:
>>
>> $ "cc" /OBJECT=[.bin_vms] ...
>>
>> seem to come about because jam insists on wrapping the cc with quotes. 
>> Is
>> there some reason it is doing that, or a way to get it to stop?
>
> OK, I didn't know that restriction :-\ And while I was making changes to
> account for that I noticed a few more path related issues, thanks to the
> log you posted :-)
>
> I'm attaching a modified build.jam which hopefully works better for you.
> And of course point out any failures and successes.
>
>> Note that in the example below, I'm using the gnv bash shell on VMS (a 
>> Gnu
>> Unix emulation environment for VMS).  But I get the same errors if I use 
>> the
>> native VMS shell.
>
> I think bjam executes commands in the native VMS shell so where you
> first execute from doesn't alter the build.
>
> NOTE: The version of build.jam attached is against the one in Boost
> 1.33.1 which is basically the same as the one in Boost 1.33.0. If you
> need one against the Boost 1.34.0 (aka CVS HEAD) I can post that also.
>
>
> -- 
> -- Grafik - Don't Assume Anything
> -- Redshift Software, Inc. - http://redshift-software.com
> -- rrivera/acm.org - grafik/redshift-software.com
> -- 102708583/icq - grafikrobot/aim - Grafik/jabber.org
>

--------------------------------------------------------------------------------

> #~ Copyright 2002-2005 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)
>
> # Platform related specifics.
> if $(NT) || $(OS2) {
>    rule .path { if $(>) { return "$(<:J=\\)\\$(>:J=)" ; } else { return 
> "$(<:J=\\)" ; } } }
> else if $(VMS) {
>    rule .path { if $(>) { return "[.$(<:J=/)]$(>:J=)" ; } else { return 
> "[.$(<:J=/)]" ; } } }
> else if $(MAC) {
>    rule .path { if $(>) { return ":$(<:J=\:)\:$(>:J=)" ; } else { return 
> ":$(<:J=\:)" ; } } }
> else {
>    rule .path { if $(>) { return "$(<:J=/)/$(>:J=)" ; } else { return 
> "$(<:J=/)" ; } } }
> if $(VMS) { . = "_" ; }
> else { . = "." ; }
> if $(VMS) { ~ = "" ; }
> else { ~ = "\"" ; }
>
> # Info about what we are building.
> NAME = boost-jam ;
> VERSION = 3$(.)1$(.)11 ;
> RELEASE = 1 ;
> LICENSE = 1_0 ;
>
> HAVE_PYTHON = 0 ;
> PYTHON_INCUDES = /usr/include/python2.3 ;
> PYTHON_LIB = -lpython2.3 ;
>
>
> # Generate development debug binaries?
> if --debug in $(ARGV)
> {
>    debug = true ;
> }
>
> # Attempt to generate and/or build the grammar?
> if --grammar in $(ARGV)
> {
>    grammar = true ;
> }
>
> # Do we need to add a default build type argument?
> if ! ( --release in $(ARGV) ) &&
>   ! ( --debug in $(ARGV) )
> {
>    ARGV += --release ;
> }
>
> # An explicit root for the toolset? (trim spaces)
> toolset-root = [ MATCH --toolset-root=(.*) : $(ARGV) ] ;
> {
>    local t = [ MATCH "[ ]*(.*)" : $(toolset-root:J=" ") ] ;
>    toolset-root = ;
>    while $(t)
>    {
>        t = [ MATCH "([^ ]+)([ ]*)(.*)" : $(t) ] ;
>        toolset-root += $(t[1]) ;
>        if $(t[3]) { toolset-root += $(t[2]) ; }
>        t = $(t[3]) ;
>    }
>    toolset-root = $(toolset-root:J="") ;
> }
>
> # Configure the implemented toolsets. These are minimal
> # commands and options to compile the full Jam. When
> # adding new toolsets make sure to add them to the
> # "known" list also.
> rule toolset ( name command .type ? : opt.out + : opt.define * : flags * : 
> linklibs * )
> {
>    .type ?= "" ;
>    tool.$(name)$(.type).cc ?= $(command) ;
>    tool.$(name)$(.type).opt.out ?= $(opt.out) ;
>    tool.$(name)$(.type).opt.define ?= $(opt.define) ;
>    tool.$(name)$(.type).flags ?= $(flags) ;
>    tool.$(name)$(.type).linklibs ?= $(linklibs) ;
>    if ! $(name) in $(toolsets) { toolsets += $(name) ; }
> }
> rule opt ( type : yes-opt * : no-opt * ) { if $(type) in $(ARGV) { return 
> $(yes-opt) ; } else { return $(no-opt) ; } }
> ## HP-UX aCC compiler
> toolset acc cc : "-o " : -D
>    : -Ae
>    [ opt --release : -s -O3 ]
>    [ opt --debug : -g -pg ] ;
> ## Borland C++ 5.5.x
> toolset borland bcc32 : -e -n : /D
>    : -WC -w- -q "-I$(toolset-root)Include" "-L$(toolset-root)Lib"
>    [ opt --release : -O2 -vi -w-inl ]
>    [ opt --debug : -v -Od -vi- ] ;
> ## Generic Unix cc
> if ! $(CC) { CC = cc ; }
> toolset cc $(CC) : "-o " : -D
>    : $(CFLAGS)
>    [ opt --release : -s -O ]
>    [ opt --debug : -g ]
>    : $(LIBS) ;
> ## Comeau C/C++ 4.x
> toolset como como : "-o " : -D
>    : --c
>    [ opt --release : --inlining ]
>    [ opt --debug : --no_inlining ] ;
> ## MacOSX Darwin, using GCC 2.9.x, 3.x
> toolset darwin cc :  "-o " : -D
>    :
>    [ opt --release : -Wl,-x -O3 -finline-functions ]
>    [ opt --debug : -g -O0 -fno-inline -pg ] ;
> ## GCC 2.x, 3.x
> toolset gcc gcc : "-o " : -D
>    : -pedantic
>    [ opt --release : [ opt --symbols : -g : -s ] -O3 -finline-functions ]
>    [ opt --debug : -g -O0 -fno-inline ] ;
> ## GCC 2.x, 3.x on CYGWIN but without cygwin1.dll
> toolset gcc-nocygwin gcc : "-o " : -D
>    : -s -O3 -mno-cygwin
>    [ opt --release : -finline-functions ]
>    [ opt --debug : -s -O3 -fno-inline -pg ] ;
> ## Intel C/C++ for Linux
> toolset intel-linux icc : "-o " : -D
>    :
>    [ opt --release : -Xlinker -s -O3 ]
>    [ opt --debug : -g -O0 -p ] ;
> ## Intel C/C++ for Win32
> toolset intel-win32 icl : /Fe : -D
>    : /nologo
>    [ opt --release : /ML /O2 /Ob2 /Gy /GF /GA /GB ]
>    [ opt --debug : /MLd /DEBUG /Z7 /Od /Ob0 ] ;
> ## KCC ?
> toolset kcc KCC : "-o " : -D
>    :
>    [ opt --release : -s +K2 ]
>    [ opt --debug : -g +K0 ] ;
> ## Borland Kylix
> toolset kylix bc++ : -o : -D
>    : -tC -q
>    [ opt --release : -O2 -vi -w-inl ]
>    [ opt --debug : -v -Od -vi- ] ;
> ## Metrowerks CodeWarrior 8.x
> {
>    # Even though CW can compile all files at once, it crashes if it tries 
> in the bjam case.
>    local mwcc = ; if $(NT) { mwcc = mwcc ; } else { mwcc = mwc$(OSPLAT:L) 
> ; }
>    mwcc ?= mwcc ;
>    toolset metrowerks $(mwcc) : "-o " : -D
>        : -c -lang c -subsystem console -cwd include
>        [ opt --release : -runtime ss -opt full -inline all ]
>        [ opt --debug : -runtime ssd -opt none -inline off ] ;
>    toolset metrowerks $(mwcc) .link : "-o " :
>        : -subsystem console -ladvapi32.lib
>        [ opt --release : -runtime ss ]
>        [ opt --debug : -runtime ssd ] ;
> }
> ## MINGW GCC
> toolset mingw gcc : "-o " : -D
>    :
>    [ opt --release : -s -O3 -finline-functions ]
>    [ opt --debug : -g -O0 -fno-inline -pg ] ;
> ## MIPS Pro
> toolset mipspro cc : "-o " : -D
>    :
>    [ opt --release : -s -O3 -g0 -INLINE:none ]
>    [ opt --debug : -g -O0 -INLINE ] ;
> ## Microsoft Visual Studio C++ 6.x
> toolset msvc cl : /Fe : -D
>    : /nologo
>    [ opt --release : /ML /O2 /Ob2 /Gy /GF /GA /GB ]
>    [ opt --debug : /MLd /DEBUG /Z7 /Od /Ob0 ]
>    : kernel32.lib advapi32.lib ;
> ## QNX 6.x GCC 3.x/2.95.3
> toolset qcc qcc : "-o " : -D
>    : -pedantic
>    [ opt --release : [ opt --symbols : -g : -s ] -O3 -finline-functions ]
>    [ opt --debug : -g -O0 -fno-inline ] ;
> ## Sun Workshop 6 C++
> toolset sunpro cc : "-o " : -D
>    :
>    [ opt --release : -s -fast -xO4 ]
>    [ opt --debug : -g ] ;
> ## Compaq Alpha CXX
> toolset tru64cxx cc : "-o " : -D
>    :
>    [ opt --release : -s -O5 -inline speed ]
>    [ opt --debug : -g -O0 -pg ] ;
> ## IBM VisualAge C++
> toolset vacpp xlc : "-o " : -D
>    :
>    [ opt --release : -s -O3 -qstrict -qinline ]
>    [ opt --debug : -g -qNOOPTimize -qnoinline -pg ] ;
> ## Microsoft Visual C++ .NET 7.x
> toolset vc7 cl : /Fe : -D
>    : /nologo
>    [ opt --release : /ML /O2 /Ob2 /Gy /GF /GA /GB ]
>    [ opt --debug : /MLd /DEBUG /Z7 /Od /Ob0 ]
>    : kernel32.lib advapi32.lib ;
> ## VMS/OpenVMS DEC C
> toolset vmsdecc cc : /OBJECT= : "/DEFINES=(" "," ")"
>    : /STANDARD=VAXC /PREFIX_LIBRARY_ENTRIES=ALL_ENTRIES
>    [ opt --release : /OPTIMIZE /NODEBUG ]
>    [ opt --debug : /NOOPTIMIZE /DEBUG ]
>    ;
> toolset vmsdecc link .link : /EXECUTABLE= :
>    : /NOMAP
>    [ opt --release : /NODEBUG ]
>    [ opt --debug : /DEBUG ]
>    ;
>
> # First set the build commands and options according to the
> # preset toolset.
> toolset = [ MATCH --toolset=(.*) : $(ARGV) ] ;
> if ! $(toolset)
> {
>    # For some reason, the following test does not catch
>    # empty toolset.
>    ECHO "###" ;
>    ECHO "###" No toolset specified. Please use --toolset option. ;
>    ECHO "###" ;
>    ECHO "###" Known toolsets are: $(toolsets:J=", ") ;
>    EXIT "###" ;
> }
> if ! $(toolset) in $(toolsets)
> {
>    ECHO "###" ;
>    ECHO "###" Unknown toolset: $(toolset) ;
>    ECHO "###" ;
>    ECHO "###" Known toolsets are: $(toolsets:J=", ") ;
>    EXIT "###" ;
> }
> --cc = $(tool.$(toolset).cc) ;
> if $(tool.$(toolset).opt.out[2])
> {
>    --bin = $(tool.$(toolset).opt.out[1]) ;
>    --dir = $(tool.$(toolset).opt.out[2]) ;
> }
> else
> {
>    --out = $(tool.$(toolset).opt.out) ;
> }
> --def = $(tool.$(toolset).opt.define) ;
> --flags = $(tool.$(toolset).flags) ;
> --defs = $(tool.$(toolset).defines) ;
> --libs = $(tool.$(toolset).linklibs) ;
> if $(tool.$(toolset).link.cc)
> {
>    --link = $(tool.$(toolset).link.cc) ;
>    if $(tool.$(toolset).link.opt.out[2])
>    {
>        --link-bin = $(tool.$(toolset).link.opt.out[1]) ;
>        --link-dir = $(tool.$(toolset).link.opt.out[2]) ;
>    }
>    else
>    {
>        --link-out = $(tool.$(toolset).link.opt.out) ;
>    }
>    --link-def = $(tool.$(toolset).link.opt.define) ;
>    --link-flags = $(tool.$(toolset).link.flags) ;
>    --link-defs = $(tool.$(toolset).link.defines) ;
>    --link-libs = $(tool.$(toolset).link.linklibs) ;
> }
>
> # Put executables in platform-specific subdirectory.
> locate-target = $(LOCATE_TARGET) ;
> if $(VMS)
> {
>    locate-target ?= bin$(.)vms ;
>    platform = vms ;
> }
> else if $(MAC)
> {
>    locate-target ?= bin$(.)$(OS:L)$(OSPLAT:L) ;
>    platform = $(OS:L)$(OSPLAT:L) ;
> }
> else if $(OSPLAT)
> {
>    locate-target ?= bin$(.)$(OS:L)$(OSPLAT:L) ;
>    platform = $(OS:L)$(OSPLAT:L) ;
> }
> else
> {
>    locate-target ?= bin$(.)$(OS:L) ;
>    platform = $(OS:L) ;
> }
> if $(debug)
> {
>    locate-target = [ .path $(locate-target)$(.)debug ] ;
> }
> else
> {
>    locate-target = [ .path $(locate-target) ] ;
> }
>
> if --show-locate-target in $(ARGV)
> {
>  ECHO $(locate-target) ;
> }
>
> # We have some different files for UNIX, VMS, and NT.
> jam.source =
>    command.c compile.c expand.c glob.c
>    hash.c hcache.c headers.c hdrmacro.c
>    jam.c jambase.c jamgram.c
>    lists.c make.c make1.c newstr.c
>    option.c parse.c regexp.c rules.c
>    scan.c search.c subst.c
>    timestamp.c variable.c modules.c strings.c filesys.c
>    builtins.c pwd.c class.c native.c modules/set.c
>    modules/path.c modules/regex.c modules/property-set.c
>    modules/sequence.c modules/order.c
>    ;
> if $(NT)
> {
>    jam.source += execnt.c filent.c pathunix.c w32_getreg.c ;
> }
> else if $(OS2)
> {
>    jam.source += execunix.c fileos2.c pathunix.c ;
> }
> else if $(VMS)
> {
>    jam.source += execvms.c filevms.c pathvms.c ;
> }
> else if $(MAC)
> {
>    jam.source += execmac.c filemac.c pathmac.c ;
> }
> else
> {
>    jam.source += execunix.c fileunix.c pathunix.c ;
> }
>
> # Debug assertions, or not.
> if ! $(debug) || --noassert in $(ARGV)
> {
>    --defs += NDEBUG ;
> }
>
> # Enable some optional features.
> --defs += OPT_HEADER_CACHE_EXT ;
> --defs += OPT_GRAPH_DEBUG_EXT ;
> --defs += OPT_SEMAPHORE ;
>
> # Bug fixes
> --defs += OPT_FIX_TARGET_VARIABLES_EXT ;
> #~ --defs += OPT_NO_EXTERNAL_VARIABLE_SPLIT ;
>
> # Improvements
> --defs += OPT_IMPROVED_PATIENCE_EXT ;
>
> if ( $(OS) = NT || $(NT) ) && ! NT in $(--defs)
> {
>    --defs += NT ;
> }
> if $(VMS)
> {
>    --defs += VMS ;
> }
> --defs += YYSTACKSIZE=5000 ;
>
> if $(HAVE_PYTHON) = 1
> {
>    --defs += HAVE_PYTHON ;
>    --flags += -I$(PYTHON_INCUDES) ;
>    --flags += -Wno-long-long ;
>    --libs += $(PYTHON_LIB) ;
> }
>
>
>
> # The basic symbolic targets...
> NOTFILE all clean dist ;
> ALWAYS clean ;
>
> # Utility rules and actions...
> rule .clean
> {
>    [DELETE] clean : $(<) ;
> }
> if $(NT) { actions piecemeal together existing [DELETE] {
>    del /F /Q $(>)
> } }
> if $(UNIX) { actions piecemeal together existing [DELETE] {
>    rm -f $(>)
> } }
> if $(VMS) { actions piecemeal together existing [DELETE] {
>    DELETE $(>[--2]:J=";*, ") $(>[-1]);*
> } }
> if $(NT) {
>    --chmod+w = "attrib -r " ;
> }
> if $(UNIX) {
>    --chmod+w = "chmod +w " ;
> }
> if $(VMS) {
>    --chmod+w = "SET FILE/PROT=(S:RWED) " ;
> }
>
> rule .mkdir
> {
>    NOUPDATE $(<) ;
>    if $(<:P) { DEPENDS $(<) : $(<:P) ; .mkdir $(<:P) ; }
>    if ! $(md<$(<)>) { [MKDIR] $(<) ; md<$(<)> = - ; }
> }
> if $(NT) { actions [MKDIR] {
>    md $(<)
> } }
> if $(UNIX) { actions [MKDIR] {
>    mkdir $(<)
> } }
> if $(VMS) { actions [MKDIR] {
>    CREATE/DIR $(<J=", ")
> } }
>
> rule .exe
> {
>    local exe = $(<) ;
>    if $(NT) || ( $(UNIX) && $(OS) = CYGWIN ) || $(VMS) { exe = 
> $(exe:S=.exe) ; }
>    LOCATE on $(exe) = $(locate-target) ;
>    DEPENDS all : $(exe) ;
>    .mkdir $(locate-target) ;
>    if $(--link)
>    {
>        local objs = ;
>        for local s in $(>)
>        {
>            # Translate any subdir elements into a simple file name.
>            local parts = [ MATCH "([^/]+)[/]?(.*)" : $(s) ] ;
>            if ! $(parts[-1]) { parts = $(parts[1--2]) ; }
>            local o = $(parts:J=_) ;
>            o = $(o:S=.o) ;
>            objs += $(o) ;
>            LOCATE on $(o) = $(locate-target) ;
>            DEPENDS $(exe) : $(o) ;
>            DEPENDS $(o) : [ .path $(parts) ] ;
>            DEPENDS $(o) : $(locate-target) ;
>            [COMPILE] $(o) : [ .path $(parts) ] ;
>            .clean $(o) ;
>        }
>        DEPENDS $(exe) : $(objs) ;
>        DEPENDS $(exe) : $(locate-target) ;
>        [COMPILE.LINK] $(exe) : $(objs) ;
>        .clean $(exe) ;
>    }
>    else
>    {
>        DEPENDS $(exe) : $(>) ;
>        DEPENDS $(exe) : $(locate-target) ;
>        [COMPILE] $(exe) : $(>) ;
>        .clean $(exe) ;
>    }
>    return $(exe) ;
> }
> if ! $(--def[2]) { actions [COMPILE] {
>    $(~)$(--cc)$(~) $(--bin)$(<:D=) $(--dir)$(<:D) $(--out)$(<) 
> $(--def)$(--defs) $(--flags) "$(--libs)" $(>)
> } }
> else { actions [COMPILE] {
>    $(~)$(--cc)$(~) $(--bin)$(<:D=) $(--dir)$(<:D) $(--out)$(<) 
> $(--def[1])$(--defs:J=$(--def[2]))$(--def[3]) $(--flags) "$(--libs)" $(>)
> } }
> if $(VMS) { actions [COMPILE.LINK] {
>    $(~)$(--link)$(~) $(--link-bin)$(<:D=) $(--link-dir)$(<:D) 
> $(--link-out)$(<) $(--link-def)$(--link-defs) $(--link-flags) 
> "$(--link-libs)" $(>J=", ")
> } }
> else { actions [COMPILE.LINK] {
>    $(~)$(--link)$(~) $(--link-bin)$(<:D=) $(--link-dir)$(<:D) 
> $(--link-out)$(<) $(--link-def)$(--link-defs) $(--link-flags) 
> "$(--link-libs)" $(>)
> } }
>
> rule .link
> {
>    DEPENDS all : $(<) ;
>    DEPENDS $(<) : $(>) ;
>    [LINK] $(<) : $(>) ;
>    .clean $(<) ;
> }
> if $(NT) { actions [LINK] {
>    copy $(>) $(<)
> } }
> if $(UNIX) { actions [LINK] {
>    ln -fs $(>) $(<)
> } }
> if $(VMS) { actions [LINK] {
>    COPY/REPLACE $(>) $(<)
> } }
>
> rule .move
> {
>    DEPENDS $(<) : $(>) ;
>    [MOVE] $(<) : $(>) ;
> }
> if $(NT) { actions [MOVE] {
>    del /f $(<)
>    rename $(>) $(<)
> } }
> if $(UNIX) { actions [MOVE] {
>    mv -f $(>) $(<)
> } }
> if $(VMS) { actions [MOVE] {
>    RENAME $(>) $(<)
> } }
>
> # Generate the grammar tokens table, and the real yacc grammar.
> rule .yyacc
> {
>    local exe = [ .exe yyacc : yyacc.c ] ;
>    NOUPDATE $(exe) ;
>    DEPENDS $(<) : $(exe) $(>) ;
>    LEAVES $(<) ;
>    yyacc.exe on $(<) = $(exe:R=$(locate-target)) ;
>    [YYACC] $(<) : $(>) ;
> }
> actions [YYACC] {
>    $(--chmod+w)$(<[1])
>    $(--chmod+w)$(<[2])
>    "$(yyacc.exe)" $(<) $(>)
> }
> if $(grammar)
> {
>    .yyacc jamgram.y jamgramtab.h : jamgram.yy ;
> }
> else if $(debug)
> {
>    .exe yyacc : yyacc.c ;
> }
>
> # How to build the grammar.
> if $(NT)
> {
>    SUFEXE = .exe ;
>    # try some other likely spellings...
>    PATH ?= $(Path) ;
>    PATH ?= $(path) ;
> }
> SUFEXE ?= "" ;
>
> yacc ?= [ GLOB $(PATH) : yacc$(SUFEXE) ] ;
> yacc ?= [ GLOB $(PATH) : bison$(SUFEXE) ] ;
> yacc ?= [ GLOB "$(ProgramFiles:J= )\\GnuWin32\\bin" "C:\\Program 
> Files\\GnuWin32\\bin" : bison$(SUFEXE) ] ;
> yacc = $(yacc[1]) ;
> switch $(yacc:D=:S=)
> {
>    case bison : yacc += -d --yacc ;
>    case yacc  : yacc += -d ;
> }
> if $(debug) && $(yacc)
> {
>    yacc += -t -v ;
> }
> yacc += $(YACCFLAGS) ;
>
> rule .yacc
> {
>    DEPENDS $(<) : $(>) ;
>    LEAVES $(<) ;
>    [YACC] $(<) : $(>) ;
> }
> if $(NT) { actions [YACC] {
>    "$(yacc)" $(>)
>    if not errorlevel 1 (
>        del /f $(<[1])
>        rename y.tab$(<[1]:S) $(<[1])
>        del /f $(<[2])
>        rename y.tab$(<[2]:S) $(<[2])
>    ) else set _error_ =
> } }
> if $(UNIX) { actions [YACC] {
>    if ` "$(yacc)" $(>) ` ; then
>        mv -f y.tab$(<[1]:S) $(<[1])
>        mv -f y.tab$(<[2]:S) $(<[2])
>    else
>        exit 1
>    fi
> } }
> if $(VMS) { actions [YACC] {
>    IF "$(yacc)" $(>)
>    THEN
>        RENAME y_tab$(<[1]:S) $(<[1])
>        RENAME y_tab$(<[2]:S) $(<[2])
>    ENDIF
> } }
> if $(grammar) && ! $(yacc)
> {
>    EXIT "Could not find the 'yacc' tool, and therefore can not build the 
> grammar." ;
> }
> if $(grammar) && $(yacc)
> {
>    .yacc jamgram.c jamgram.h : jamgram.y ;
> }
>
> # How to build the compiled in jambase.
> rule .mkjambase
> {
>    local exe = [ .exe mkjambase : mkjambase.c ] ;
>    DEPENDS $(<) : $(exe) $(>) ;
>    LEAVES $(<) ;
>    mkjambase.exe on $(<) = $(exe:R=$(locate-target)) ;
>    [MKJAMBASE] $(<) : $(>) ;
> }
> actions [MKJAMBASE] {
>    $(--chmod+w)$(<)
>    $(mkjambase.exe) $(<) $(>)
> }
> if $(debug)
> {
>    .mkjambase jambase.c : Jambase ;
> }
>
> # How to build Jam.
> rule .jam
> {
>    $(>).exe = [ .exe $(>) : $(jam.source) ] ;
>    DEPENDS all : $($(>).exe) ;
>
>    if $(debug)
>    {
>        $(<).exe = $(<:S=$($(>).exe:S)) ;
>        LOCATE on $($(<).exe) = $(locate-target) ;
>        .link $($(<).exe) : $($(>).exe) ;
>        DEPENDS all : $($(<).exe) ;
>    }
> }
> .jam jam : bjam ;
>
> # Scan sources for header dependencies.
> # WARNING: Yes those are *REAL TABS* below. DO NOT CHANGE,
> # under any circumstances, to spaces!! And the tabs
> # indenting this are so that if someone is in the mood to
> # replace tabs they hit this comment, and hopefully notice
> # their error.
> rule .scan
> {
>    HDRRULE on $(<:D=) = .hdr.scan ;
>    HDRSCAN on $(<:D=) = "^[ ]*#[ ]*include[ ]*([<\"][^\">]*[\">]).*$" ;
> }
> rule .hdr.scan
> {
>    local hdrs = [ GLOB . : $(>:D=) ] ;
>    INCLUDES $(<:D=) : $(hdrs:D=) ;
>    HDRRULE on $(>:D=) = .hdr.scan ;
>    HDRSCAN on $(>:D=) = "^[ ]*#[ ]*include[ ]*([<\"][^\">]*[\">]).*$" ;
> }
> .scan [ GLOB . : *.c ] ;
>
> # Distribution making from here on out.
> dist.license =
>    #~ [ GLOB . : LICENSE_$(LICENSE).txt ] [ GLOB [ .path .. .. .. ] : 
> LICENSE_$(LICENSE).txt ] ;
>    [ GLOB . : LICENSE_$(LICENSE).txt ]
>    [ GLOB [ .path .. .. .. ] : LICENSE_$(LICENSE).txt ]
>    [ GLOB [ .path .. boost ] : LICENSE_$(LICENSE).txt ] ;
> dist.docs =
>    $(dist.license[1])
>    index.html
>    Porting
>    Jam.html
>    ;
> dist.source =
>    [ GLOB . : *.c *.h ]
>    ;
> dist.source = $(dist.source:D=)
>    $(dist.docs)
>    build.jam build.bat build.sh build_vms.com
>    Jambase
>    jamgram.y jamgram.yy
>    [ .path debian : changelog ]
>    [ .path debian : control ]
>    [ .path debian : copyright ]
>    [ .path debian : jam.man.sgml ]
>    [ .path debian : rules ]
>    [ .path modules : set.c ]
>    [ .path modules : path.c ]
>    [ .path modules : regex.c ]
>    [ .path modules : property-set.c ]
>    [ .path modules : sequence.c ]
>    [ .path modules : order.c ]
>    boost-jam.spec
>    ;
> dist.bin =
>    bjam
>    ;
> dist.bin =
>    $(dist.license[1])
>    $(dist.bin:S=$(bjam.exe:S))
>    ;
>
> if $(NT)
> {
>    zip ?= [ GLOB "$(ProgramFiles:J= )\\7-ZIP" "C:\\Program Files\\7-ZIP" : 
> "7z.exe" "7zn.exe" ] ;
>    zip ?= [ GLOB $(PATH) : zip.exe ] ;
>    zip ?= zip ;
>    zip = $(zip[1]) ;
>    switch $(zip:D=:S=)
>    {
>        case 7z* : zip += a -r -tzip -mx=9 ;
>        case zip  : zip += -9r ;
>    }
>    actions piecemeal [PACK] {
>    "$(zip)" "$(<)" "$(>)"
>    }
>    actions piecemeal [ZIP] {
>    "$(zip)" "$(<)" "$(>)"
>    }
>    actions piecemeal [COPY] {
>    copy /Y "$(>)" "$(<)" >NUL:
>    }
> }
> if $(UNIX)
> {
>    actions [PACK] {
>    tar zcf "$(<)" "$(>)"
>    }
>    actions [ZIP] {
>    gzip -c9 "$(>)" > "$(<)"
>    }
>    actions [COPY] {
>    cp -Rpf "$(>)" "$(<)"
>    }
> }
>
> # The single binary, compressed.
> rule .binary
> {
>    local zip = ;
>    if $(NT) { zip = $($(<).exe:S=.zip) ; }
>    if $(UNIX) { zip = $($(<).exe:S=.tgz) ; }
>    zip = $(zip:S=)-$(VERSION)-$(RELEASE)-$(platform)$(zip:S) ;
>    DEPENDS $(zip) : $($(<).exe) ;
>    DEPENDS dist : $(zip) ;
>    #~ LOCATE on $(zip) = $(locate-target) ;
>    if $(NT) { [ZIP] $(zip) : $($(<).exe) ; }
>    if $(UNIX) { [PACK] $(zip) : $($(<).exe) ; }
>    .clean $(zip) ;
> }
>
> # Package some file.
> rule .package ( dst-dir : src-files + )
> {
>    local dst-files ;
>    for local src-path in $(src-files)
>    {
>        local src-subdir = $(src-path:D) ;
>        local src-file = $(src-path) ;
>        while $(src-subdir:D) { src-subdir = $(src-subdir:D) ; }
>        if $(src-subdir) = ".."
>        {
>            src-file = $(src-file:D=) ;
>        }
>        dst-files += $(src-file:R=$(dst-dir)) ;
>    }
>
>    local pack = ;
>    if $(NT) { pack = $(dst-dir).zip ; }
>    if $(UNIX) { pack = $(dst-dir).tgz ; }
>
>    DEPENDS dist : $(pack) ;
>    DEPENDS $(pack) : $(dst-files) ;
>
>    local dst-files-queue = $(dst-files) ;
>    for local src-path in $(src-files)
>    {
>        local dst-file = $(dst-files-queue[1]) ;
>        dst-files-queue = $(dst-files-queue[2-]) ;
>        DEPENDS $(dst-file) : $(src-path) $(dst-file:D) ;
>        .mkdir $(dst-file:D) ;
>
>        [COPY] $(dst-file) : $(src-path) ;
>        .clean $(dst-file) ;
>    }
>
>    [PACK] $(pack) : $(dst-files) ;
>    .clean $(pack) ;
> }
>
> # RPM distro file.
> rpm-tool = [ GLOB $(PATH) : "rpmbuild" "rpm" ] ;
> rule .rpm ( name : source )
> {
>    local rpm-arch = ;
>    switch $(OSPLAT)
>    {
>        case X86       : rpm-arch ?= i386 ;
>        case PPC       : rpm-arch ?= ppc ;
>        case AXP       : rpm-arch ?= alpha ;
>        # no guaranty for these:
>        case IA64      : rpm-arch ?= ia64 ;
>        case ARM       : rpm-arch ?= arm ;
>        case SPARC     : rpm-arch ?= sparc ;
>        case *         : rpm-arch ?= other ;
>    }
>    local target = $(name)-rpm ;
>    NOTFILE $(target) ;
>    DEPENDS dist : $(target) ;
>    DEPENDS $(target) : $(name).$(rpm-arch).rpm $(name).src.rpm ;
>    DEPENDS $(name).$(rpm-arch).rpm : $(source) ;
>    DEPENDS $(name).src.rpm : $(name).$(rpm-arch).rpm ;
>    docs on $(target) = $(dist.docs:J=" ") ;
>    arch on $(target) = $(rpm-arch) ;
>    if $(rpm-arch) = ppc { target-opt on $(target) = --target= ; }
>    else { target-opt on $(target) = "--target " ; }
>    [RPM] $(target) : $(source) ;
>    .clean $(name).$(rpm-arch).rpm $(name).src.rpm ;
> }
> actions [RPM] {
>    export BOOST_JAM_TOOLSET="$(toolset)"
>    $(rpm-tool[1]) -ta $(target-opt)$(arch) $(>) | tee rpm.out
>    cp `grep -e '^Wrote:' rpm.out | sed 's/^Wrote: //'` .
>    rm -f rpm.out
> }
>
> # The distribution targets. Don't bother with the targets if
> # distribution build not requested.
> if dist in $(ARGV)
> {
>    #~ .binary bjam ;
>    .package $(NAME)-$(VERSION) : $(dist.source) ;
>    .package $(NAME)-$(VERSION)-$(RELEASE)-$(platform) : $(dist.bin) ;
>    if $(rpm-tool)
>    {
>        .rpm $(NAME)-$(VERSION)-$(RELEASE) : $(NAME)-$(VERSION).tgz ;
>    }
> }
>

--------------------------------------------------------------------------------

> _______________________________________________
> Boost-users mailing list
> Boost-users_at_[hidden]
> http://lists.boost.org/mailman/listinfo.cgi/boost-users