ceph/src/boost/tools/build/src/tools/vmsdecc.jam

   1 #  Copyright (c) 2015 Artur Shepilko
   2 #
   3 #  Use, modification and distribution is subject to the Boost Software
   4 #  License Version 1.0. (See accompanying file LICENSE.txt or
   5 #  https://www.bfgroup.xyz/b2/LICENSE.txt)
   6
   7 # Implements OpenVMS-based HP DECC/C++ toolset.
   8 # Relies on POSIX-style path handling bjam/B2 implementation for VMS.
   9
  10 import "class" : new ;
  11 import property ;
  12 import generators ;
  13 import os ;
  14 import toolset : flags ;
  15 import feature ;
  16 import type ;
  17 import common ;
  18 import unix ;
  19 import path ;
  20
  21
  22 if [ MATCH (--debug-configuration) : [ modules.peek : ARGV ] ]
  23 {
  24     .debug-configuration = true ;
  25 }
  26
  27 feature.extend toolset : vmsdecc ;
  28
  29 toolset.inherit-generators  vmsdecc : unix : unix.link unix.link.dll ;
  30 toolset.inherit-flags vmsdecc : unix ;
  31 toolset.inherit-rules vmsdecc : unix ;
  32
  33 generators.override vmsdecc.archive-generator : builtin.archive-generator ;
  34 generators.override vmsdecc.prebuilt : builtin.prebuilt ;
  35 generators.override vmsdecc.searched-lib-generator : searched-lib-generator ;
  36
  37 type.set-generated-target-suffix EXE : <toolset>vmsdecc <target-os>vms : exe ;
  38 type.set-generated-target-suffix OBJ : <toolset>vmsdecc <target-os>vms : obj ;
  39 type.set-generated-target-suffix PREPROCESSED_C : <toolset>vmsdecc <target-os>vms : i ;
  40 type.set-generated-target-suffix PREPROCESSED_CPP : <toolset>vmsdecc <target-os>vms : ixx ;
  41 type.set-generated-target-suffix STATIC_LIB : <toolset>vmsdecc <target-os>vms : olb ; ## xxx.olb
  42
  43 type.register-suffixes exe : SHARED_LIB ;
  44 type.set-generated-target-prefix SHARED_LIB : <toolset>vmsdecc <target-os>vms : shr ; ## shrxxx.exe
  45 type.set-generated-target-suffix SHARED_LIB : <toolset>vmsdecc <target-os>vms : exe ; ## shrxxx.exe
  46
  47 .OBJ = .obj ; ## suffix
  48 .nl = "
  49 " ;
  50
  51 rule init ( version ? : command * : options * )
  52 {
  53     local argv = [ modules.peek : ARGV ] ;
  54
  55     local condition = [
  56       common.check-init-parameters vmsdecc : version $(version) ] ;
  57
  58     # CC and CXX are CLI commands, so no need to search for the executables
  59     command = CXX ;
  60     toolset.flags vmsdecc .CXX $(condition) : CXX ;
  61     common.handle-options vmsdecc : $(condition) : $(command) : $(options) ;
  62
  63     local command_c = $(command[1--2]) $(command[-1]:B=CC) ;
  64     toolset.flags vmsdecc .CC $(condition) : $(command_c) ;
  65
  66     local linker = [ feature.get-values <linker> : $(options) ] ;
  67     linker ?= CXXLINK ;
  68     toolset.flags vmsdecc.link .LD $(condition) :  $(linker) ;
  69     if $(.debug-configuration)
  70     {
  71         ECHO notice\: using linker "::" $(condition) "::" $(linker[1]) ;
  72     }
  73
  74     local archiver = LIB ;
  75     toolset.flags vmsdecc.archive .AR $(condition) :  $(archiver) ;
  76
  77     local b2 = $(argv[1]) ;
  78     toolset.flags vmsdecc .B2 $(condition) :  $(b2) ;
  79 }
  80
  81 # Declare generators
  82 generators.register-c-compiler vmsdecc.compile.c++.preprocess : CPP : PREPROCESSED_CPP : <toolset>vmsdecc ;
  83 generators.register-c-compiler vmsdecc.compile.c.preprocess   : C   : PREPROCESSED_C   : <toolset>vmsdecc ;
  84 generators.register-c-compiler vmsdecc.compile.c : C : OBJ : <toolset>vmsdecc ;
  85 generators.register-c-compiler vmsdecc.compile.c++ : CPP : OBJ : <toolset>vmsdecc ;
  86
  87 # Declare flags and actions for compilation
  88 flags vmsdecc.compile OPTIONS <debug-symbols>on : /DEBUG ;
  89 flags vmsdecc.compile OPTIONS <profiling>on : /DEBUG ;   ## needs PCA link options
  90 flags vmsdecc.compile OPTIONS <optimization>off : /NOOPT ;
  91 flags vmsdecc.compile OPTIONS <optimization>speed : /OPT=INLINE=SPEED/OPT=NOINLINE ;
  92 flags vmsdecc.compile OPTIONS <optimization>space : /OPT=INLINE=SIZE/OPT=NOINLINE ;
  93 flags vmsdecc.compile OPTIONS <warnings>off : /NOWARN ;
  94 flags vmsdecc.compile OPTIONS <warnings>on : /WARN ;
  95 flags vmsdecc.compile OPTIONS <warnings>all  : /WARN=ENABLE=ALL ;
  96 flags vmsdecc.compile OPTIONS <warnings>extra : /WARN=ENABLE=ALL ;
  97 flags vmsdecc.compile OPTIONS <warnings>pedantic : /WARN=ENABLE=ALL ;
  98
  99 flags vmsdecc.compile.c++ OPTIONS <inlining>off : /OPT=NOINLINE ;
 100
 101 flags vmsdecc OPTIONS <address-model>32 : /POINTER=32 ;
 102 flags vmsdecc OPTIONS <address-model>64 : /POINTER=64 ; ## /POINTER=64=ARGV argv-64
 103
 104 flags vmsdecc.compile OPTIONS <cflags> ;
 105 flags vmsdecc.compile.c++ OPTIONS <cxxflags> ;
 106 flags vmsdecc.compile DEFINES <define> ;
 107 flags vmsdecc.compile UNDEFS <undef> ;
 108 flags vmsdecc.compile INCLUDES <include> ;
 109 flags vmsdecc.compile.c++ TEMPLATE_DEPTH <c++-template-depth> ;
 110
 111 feature.feature cxx-repository          :                 : free path ; #order-sensitive ;
 112 flags vmsdecc CXX-REPOS <cxx-repository> ;
 113
 114
 115 local rule get-includes ( sources * : includes * )
 116 {
 117     local result ;
 118
 119     ## Expect POSIX-style path, quote in double-quotes
 120     for local d in $(sources:D) $(includes)
 121     {
 122         if $(d)
 123         {
 124             local QUOTE = \" ;
 125             local SEP = / ;
 126
 127             local enquote = false ;
 128             local addsep = false ;
 129
 130             s = [ SPLIT_BY_CHARACTERS $(d) : $(QUOTE) ] ;
 131
 132             if $(s) = $(d) { enquote = true ; }
 133             if [ SPLIT_BY_CHARACTERS $(s) : $(SEP) ] = $(s) { addsep = true ; }
 134
 135             if $(addsep)
 136             {
 137                 d = $(s)$(SEP) ;
 138                 enquote = true ;
 139             }
 140
 141             if $(enquote)
 142             {
 143                 d = $(QUOTE)$(d)$(QUOTE) ;
 144             }
 145
 146             if ! $(d) in $(result)
 147             {
 148                 result += $(d) ;
 149             }
 150         }
 151     }
 152
 153     return $(result) ;
 154 }
 155
 156 CXX-REPO-NAME = cxx_repository ;
 157
 158 local rule get-target-cxx-repo ( target )
 159 {
 160     return [ path.join $(target) $(CXX-REPO-NAME) ] ;
 161 }
 162
 163 rule compile.c++ ( targets * : sources * : properties * )
 164 {
 165   DEPENDS $(targets) : [ on $(targets) return $(SOURCE-INCLUDES) ] ;
 166   DEPENDS $(targets) : [ on $(targets) return $(CXX-REPOS) ] ;
 167
 168   DEFINES on $(targets) = [ on $(targets) return "__USE_STD_IOSTREAM" $(DEFINES) ] ;
 169
 170   INCLUDES on $(targets) = [ on $(targets) get-includes $(sources) : $(INCLUDES) ] ;
 171
 172   TARGET-CXX-REPO on $(targets) =  [ on $(targets[1]) get-target-cxx-repo $(LOCATE) ] ;
 173   CXX-REPOS on $(targets) = [ on $(targets) return $(TARGET-CXX-REPO) $(CXX-REPOS) ] ;
 174 }
 175
 176
 177 rule compile.c ( targets * : sources * : properties * )
 178 {
 179   DEPENDS $(targets) : [ on $(targets) return $(SOURCE-INCLUDES) ] ;
 180
 181   INCLUDES on $(targets) = [ on $(targets) get-includes $(sources) : $(INCLUDES) ] ;
 182 }
 183
 184 actions compile.c
 185 {
 186     $(.CC) $(OPTIONS) /DEF=("$(DEFINES:J=",")") /UNDEF=("$(UNDEFS:J=",")") /INC=($(INCLUDES:J=,)) /OBJ=$(<:W) $(>:W)
 187 }
 188
 189 actions compile.c++
 190 {
 191     $(.CXX) $(OPTIONS) /DEF=("$(DEFINES:J=",")") /UNDEF=("$(UNDEFS:J=",")") /INC=($(INCLUDES:J=,)) /REPO=($(CXX-REPOS:WJ=,)) /OBJ=$(<:W) $(>:W)
 192 }
 193
 194
 195
 196 # Custom linking generator to separate dependency libraries and optfiles from
 197 # the list of sources. The objfiles, libraries, and optfiles are then referenced
 198 # via properties. This allows separate qualification of object-files and libraries
 199 # on linker command line.
 200 #
 201 class vmsdecc-linking-generator : linking-generator
 202 {
 203     rule run ( project name ? : property-set : sources + )
 204     {
 205         local result = [ linking-generator.run $(project) $(name) : $(property-set)
 206             : $(sources) ] ;
 207
 208         return $(result) ;
 209     }
 210
 211     rule generated-targets ( sources + : property-set : project name ? )
 212     {
 213         local sources2 ;     # Sources to pass to inherited rule.
 214         local properties2 ;  # Properties to pass to inherited rule.
 215         local objfiles ;     # Object files.
 216         local libraries ;    # Library sources.
 217
 218         properties2 = [ $(property-set).raw ] ;
 219
 220         for local s in $(sources)
 221         {
 222             if [ type.is-derived [ $(s).type ] OBJ ]
 223             {
 224                 objfiles += $(s) ;
 225                 properties2 += <link-objfile>$(s) ;
 226             }
 227             else if [ type.is-derived [ $(s).type ] STATIC_LIB ]
 228             {
 229                 libraries += $(s) ;
 230                 properties2 += <link-staticlib>$(s) ;
 231             }
 232             else if [ type.is-derived [ $(s).type ] SHARED_LIB ]
 233             {
 234                 libraries += $(s) ;
 235                 properties2 += <link-sharedlib>$(s) ;
 236             }
 237         }
 238
 239
 240         return [ linking-generator.generated-targets $(sources)
 241             : [ property-set.create $(properties2) ] : $(project) $(name) ] ;
 242     }
 243 }
 244
 245
 246 generators.register [ new vmsdecc-linking-generator vmsdecc.link :
 247     OBJ SEARCHED_LIB STATIC_LIB SHARED_LIB : EXE : <toolset>vmsdecc ] ;
 248
 249 generators.register [ new vmsdecc-linking-generator vmsdecc.link.dll :
 250     OBJ SEARCHED_LIB STATIC_LIB SHARED_LIB : SHARED_LIB : <toolset>vmsdecc ] ;
 251
 252
 253
 254 # Declare flags and actions for linking
 255 flags vmsdecc.link OPTIONS <debug-symbols>on : /DEBUG ;
 256 # Strip the binary when no debugging is needed
 257 flags vmsdecc.link OPTIONS <debug-symbols>off : /NODEBUG ;
 258 flags vmsdecc.link OPTIONS <profiling>on : /DEBUG ; ## need "DEFINE LIB$DEBUG PCA$COLLECTOR"
 259 flags vmsdecc.link OPTIONS <linkflags> ;
 260 flags vmsdecc.link LINKPATH <library-path> ;
 261 flags vmsdecc.link FINDLIBS-ST <find-static-library> ;
 262 flags vmsdecc.link FINDLIBS-SA <find-shared-library> ;
 263 flags vmsdecc.link LIBRARIES <library-file> ;
 264 flags vmsdecc.link LINK-RUNTIME <runtime-link>static : static ;
 265 flags vmsdecc.link LINK-RUNTIME <runtime-link>shared : dynamic ;
 266 flags vmsdecc.link RPATH <dll-path> ;
 267 flags vmsdecc.link FINDLIBS-SA ;
 268
 269 feature.feature "link-objfile"          :                 : free dependency path incidental ;
 270 flags vmsdecc.link LINK-OBJS <link-objfile> ;
 271
 272 feature.feature "link-libmodule"          :                 : free dependency incidental ;
 273 flags vmsdecc.link LINK-LIBMODULES <link-libmodule> ;
 274
 275 feature.feature "link-staticlib"          :                 : free dependency path incidental ;
 276 flags vmsdecc.link LINK-LIBS <link-staticlib> ;
 277
 278 feature.feature "link-sharedlib"          :                 : free dependency path incidental ;
 279 flags vmsdecc.link LINK-SHAREDLIBS <link-sharedlib> ;
 280
 281 feature.feature "link-optfile"          :                 : free dependency path incidental ;
 282 flags vmsdecc.link LINK-OPTS <link-optfile> ;
 283
 284
 285 local rule export-target-var-contents ( var-name : values * )
 286 {
 287     local result ;
 288     local nl = "
 289 " ;
 290     local locate ;
 291
 292     if $(var-name)
 293     {
 294         result +=
 295             "$(nl)$(var-name) =" ;
 296         for local f in $(values)
 297         {
 298             locate = [ on $(f) return $(LOCATE) ] ;
 299             result +=
 300                 "$(nl)\"$(f:TG=:R=$(locate))\"" ;
 301         }
 302         result += "$(nl)    ;" ;
 303     }
 304
 305     return $(result) ;
 306 }
 307
 308 # VMS linker usually expects an explicit object module that contains main().
 309 # Yet on *NIX, the main module can be automatically resolved from a library --
 310 # this may arguably be convenient with dynamic linking, and is also used with
 311 # Boost.Test.
 312 # To handle such cases on VMS, one needs first to locate the library module
 313 # containing main(), then include it in sources for the link command.
 314 # GLOB_ARCHIVE built-in can locate the module name (globbing by symbol MAIN).
 315 # To be able to use its result during jam-parsing stage, we need to execute it
 316 # from a separate jam-file that produces a pre-defined option file for link.
 317 #
 318
 319 actions write-jam-file-contents
 320 {
 321     SET FILE /VER=1 @($(<:W):E= $(>) )
 322 }
 323
 324
 325 local rule mainmod-link-opt.generate ( jam-file : opt-file : objs * : libs * : sharedlibs * )
 326 {
 327     local nl = "
 328 " ;
 329     local $ = $ ;
 330     local @ = @ ;
 331
 332     if $(jam-file) && $(opt-file)
 333     {
 334         local .contents on $(jam-file) =
 335             "# This file was auto-generated by <toolset>$(__name__)." ;
 336
 337         .contents on $(jam-file) +=
 338             "$(nl)OPT-FILE = $(opt-file) ;" ;
 339
 340         .contents on $(jam-file) += [ on $(jam-file)
 341             export-target-var-contents "OBJS" : $(objs) ] ;
 342
 343         .contents on $(jam-file) += [ on $(jam-file)
 344             export-target-var-contents "LIBS" : $(libs) ] ;
 345
 346         .contents on $(jam-file) += [ on $(jam-file)
 347             export-target-var-contents "SHAREDLIBS" : $(sharedlibs) ] ;
 348
 349         .contents on $(jam-file) +=
 350             "$(nl).nl = \"$(nl)\" ;"
 351             ;
 352         .contents on $(jam-file) +=
 353             "$(nl)local rule get-main-members ( libs * : symbol-main ? )"
 354             "$(nl){"
 355             "$(nl)    local result ;"
 356             "$(nl)    symbol-main ?= \"MAIN\" ;"
 357             "$(nl)    for local libfile in $($)(libs)"
 358             "$(nl)    {"
 359             "$(nl)        local main = [ GLOB_ARCHIVE $($)(libfile) : : : $($)(symbol-main) ] ;"
 360             "$(nl)        if $($)(main)"
 361             "$(nl)        {"
 362             "$(nl)            result += $($)(main) ;"
 363             "$(nl)        }"
 364             "$(nl)    }"
 365             "$(nl)    return  $($)(result) ;"
 366             "$(nl)}"
 367             ;
 368         .contents on $(jam-file) +=
 369             "$(nl)local rule get-libmods ( members * )"
 370             "$(nl){"
 371             "$(nl)    local result ;"
 372             "$(nl)    for local m in $($)(members)"
 373             "$(nl)    {"
 374             "$(nl)        local lib = $($)(m:WDBS) ;"
 375             "$(nl)        local mem = $($)(m:M) ;"
 376             "$(nl)        if $($)(mem)"
 377             "$(nl)        {"
 378             "$(nl)            local mod = [ SPLIT_BY_CHARACTERS $($)(mem) : \"()\" ] ;"
 379             "$(nl)            result += $($)(lib)/INC=($($)(mod:B))/LIB ;"
 380             "$(nl)        }"
 381             "$(nl)    }"
 382             "$(nl)    return $($)(result) ;"
 383             "$(nl)}"
 384             ;
 385         .contents on $(jam-file) +=
 386             "$(nl)rule mainmod-link-opt ( opt-file : libs * : objs * )"
 387             "$(nl){"
 388             "$(nl)    local main-members = [ on $($)(opt-file[1]) get-main-members $($)(libs) ] ;"
 389             "$(nl)    LIBMODULES on $($)(opt-file[1]) = [ on $($)(opt-file[1]) get-libmods $($)(main-members[1]) ] ;"
 390             "$(nl)}"
 391             ;
 392         .contents on $(jam-file) +=
 393             "$(nl)actions mainmod-link-opt bind OBJS LIBMODULES"
 394             "$(nl){"
 395             "$(nl)    SET FILE /VER=1 $(@)($($)(<:W):E= $($)(LIBMODULES:J=,-$($)(.nl))-$($)(.nl) )"
 396             "$(nl)}"
 397             ;
 398         .contents on $(jam-file) +=
 399             "$(nl)local rule make"
 400             "$(nl){"
 401             "$(nl)    if $($)(OPT-FILE)"
 402             "$(nl)    {"
 403             "$(nl)        DEPENDS all : $($)(OPT-FILE) ;"
 404             "$(nl)        DEPENDS $($)(OPT-FILE) : $($)(LIBS) $($)(OBJS) ;"
 405             "$(nl)        mainmod-link-opt $($)(OPT-FILE) : $($)(LIBS) : $($)(OBJS) ;"
 406             "$(nl)    }"
 407             "$(nl)}"
 408             "$(nl)make all ;"
 409             ;
 410
 411         write-jam-file-contents $(jam-file) : [ on $(jam-file) return $(.contents) ] ;
 412
 413     }
 414 }
 415
 416
 417 rule link ( targets * : sources * : properties * )
 418 {
 419     DEPENDS $(targets) : [ on $(targets) return $(CXX-REPOS) ] ;
 420     DEPENDS $(targets) : [ on $(targets) return $(LINK-OBJS) ] ;
 421     DEPENDS $(targets) : [ on $(targets) return $(LINK-LIBS) ] ;
 422     DEPENDS $(targets) : [ on $(targets) return $(LINK-SHAREDLIBS) ] ;
 423     DEPENDS $(targets) : [ on $(targets) return $(LINK-OPTS) ] ;
 424     DEPENDS $(targets) : [ on $(targets) return $(LIBRARIES) ] ;
 425
 426
 427     for local s in $(sources)
 428     {
 429         local r = [ on $(s) return $(TARGET-CXX-REPO) ] ;
 430
 431         if ! $(r) in [ on $(targets[1]) return $(CXX-REPOS) ]
 432         {
 433             CXX-REPOS on $(targets[1]) += $(r) ;
 434         }
 435     }
 436
 437     local locate = [ on $(targets[1]) return $(LOCATE) ] ;
 438     LINK-MAINMOD-OPT on $(targets[1]) = $(targets[1]:TG=:R=$(locate):S=$MAINMOD.opt) ;
 439     LINK-MAINMOD-JAM on $(targets[1]) = $(targets[1]:TG=:R=$(locate):S=$MAINMOD.jam) ;
 440     #on $(targets[1]) TEMPORARY $(LINK-MAINMOD-JAM) ;
 441
 442     DEPENDS $(targets) : [ on $(targets) return $(LINK-MAINMOD-OPT) ] ;
 443     DEPENDS $(targets) : [ on $(targets) return $(LINK-MAINMOD-JAM) ] ;
 444     on $(targets[1]) DEPENDS $(LINK-MAINMOD-OPT) : $(LINK-MAINMOD-JAM) ;
 445
 446     on $(targets[1]) mainmod-link-opt.generate $(LINK-MAINMOD-JAM)
 447         : $(LINK-MAINMOD-OPT) : $(LINK-OBJS) : $(LINK-LIBS) $(LIBRARIES) : $(LINK-SHAREDLIBS) ;
 448
 449
 450 }
 451
 452 actions link bind LINK-OBJS LINK-MAINMOD-JAM LINK-MAINMOD-OPT LINK-LIBS LIBRARIES LINK-SHAREDLIBS LINK-OPTS CXX-REPOS
 453 {
 454     CXX_REPOS = "" +"$(CXX-REPOS:WJ=,)"
 455     IF (CXX_REPOS .EQS. "") THEN  CXX_REPOS = "NL:"
 456     DEF /NOLOG REPOS 'CXX_REPOS'
 457     SET FILE /VER=1 @($(<:WS=$INPUT.opt):E= $(LINK-OBJS:WJ=,-$(.nl))-$(.nl) ,$(LINK-LIBS:WJ=/LIB,-$(.nl))/LIB-$(.nl) ,$(LIBRARIES:WJ=/LIB,-$(.nl))/LIB-$(.nl) ,$(LINK-SHAREDLIBS:WJ=/SHARE,-$(.nl))/SHARE-$(.nl) )
 458     MC $(.B2) -f $(LINK-MAINMOD-JAM:W)
 459     $(.LD) $(OPTIONS) /REPO=(REPOS:) /EXE=$(<:W) $(LINK-MAINMOD-OPT:W)/OPT, $(<:WS=$INPUT.opt)/OPT ,$(LINK-OPTS:WJ=/OPT,)/OPT
 460 }
 461
 462 # Slight mods for dlls
 463 rule link.dll ( targets * : sources * : properties * )
 464 {
 465     DEPENDS $(targets) : [ on $(targets) return $(CXX-REPOS) ] ;
 466     DEPENDS $(targets) : [ on $(targets) return $(LINK-OBJS) ] ;
 467     DEPENDS $(targets) : [ on $(targets) return $(LINK-LIBS) ] ;
 468     DEPENDS $(targets) : [ on $(targets) return $(LINK-SHAREDLIBS) ] ;
 469     DEPENDS $(targets) : [ on $(targets) return $(LINK-OPTS) ] ;
 470     DEPENDS $(targets) : [ on $(targets) return $(LIBRARIES) ] ;
 471
 472     for local s in $(sources)
 473     {
 474         local r = [ on $(s) return $(TARGET-CXX-REPO) ] ;
 475
 476         if ! $(r) in [ on $(targets[1]) return $(CXX-REPOS) ]
 477         {
 478             CXX-REPOS on $(targets[1]) += $(r) ;
 479         }
 480     }
 481
 482
 483     local locate = [ on $(targets[1]) return $(LOCATE) ] ;
 484     LINK-MAINMOD-OPT on $(targets[1]) = $(targets[1]:TG=:R=$(locate):S=$MAINMOD.opt) ;
 485     LINK-MAINMOD-JAM on $(targets[1]) = $(targets[1]:TG=:R=$(locate):S=$MAINMOD.jam) ;
 486     #on $(targets[1]) TEMPORARY $(LINK-MAINMOD-JAM) ;
 487
 488     DEPENDS $(targets) : [ on $(targets) return $(LINK-MAINMOD-OPT) ] ;
 489     DEPENDS $(targets) : [ on $(targets) return $(LINK-MAINMOD-JAM) ] ;
 490     on $(targets[1]) DEPENDS $(LINK-MAINMOD-OPT) : $(LINK-MAINMOD-JAM) ;
 491
 492     on $(targets[1]) mainmod-link-opt.generate $(LINK-MAINMOD-JAM)
 493         : $(LINK-MAINMOD-OPT) : $(LINK-OBJS) : $(LINK-LIBS) $(LIBRARIES) : $(LINK-SHAREDLIBS) ;
 494
 495 }
 496
 497 actions link.dll bind LINK-OBJS LINK-MAINMOD-JAM LINK-MAINMOD-OPT LINK-LIB LINK-LIBS LIBRARIES LINK-SHAREDLIBS LINK-OPTS CXX-REPOS
 498 {
 499     CXX_REPOS = "" +"$(CXX-REPOS:WJ=,)"
 500     IF (CXX_REPOS .EQS. "") THEN  CXX_REPOS = "NL:"
 501     DEF /NOLOG REPOS 'CXX_REPOS'
 502     SET FILE /VER=1 @($(<:WS=$INPUT.opt):E= $(LINK-OBJS:WJ=,-$(.nl))-$(.nl) ,$(LINK-LIBS:WJ=/LIB,-$(.nl))/LIB-$(.nl) ,$(LIBRARIES:WJ=/LIB,-$(.nl))/LIB-$(.nl) ,$(LINK-SHAREDLIBS:WJ=/SHARE,-$(.nl))/SHARE-$(.nl) )
 503     MC $(.B2) -f $(LINK-MAINMOD-JAM:W)
 504     $(.LD) $(OPTIONS) /REPO=(REPOS:) /SHARE=$(<:W) $(LINK-MAINMOD-OPT:W)/OPT, $(<:WS=$INPUT.opt)/OPT ,$(LINK-OPTS:WJ=/OPT,)/OPT
 505 }
 506
 507
 508
 509 flags vmsdecc.archive AROPTIONS <archiveflags> ;
 510
 511
 512 local rule vms-join-wildcard-name ( path * : name )
 513 {
 514     local files ;
 515
 516     if $(name)
 517     {
 518         for local d in $(path)
 519         {
 520             files += $(d)$(name) ;
 521         }
 522
 523         files ?= $(name) ;
 524
 525     }
 526
 527     return $(files) ;
 528 }
 529
 530
 531 rule archive ( targets + : sources * : properties * )
 532 {
 533     local clean.a = $(targets[1])(clean) ;
 534     TEMPORARY $(clean.a) ;
 535     NOCARE $(clean.a) ;
 536     LOCATE on $(clean.a) = [ on $(targets[1]) return $(LOCATE) ] ;
 537     DEPENDS $(clean.a) : $(sources) ;
 538     DEPENDS $(targets) : $(clean.a) ;
 539     common.RmTemps $(clean.a) : $(targets) ;
 540
 541
 542     #CXX-REPOS on $(targets[1]) = null ;  ## reset
 543
 544     for local s in $(sources)
 545     {
 546         local r = [ on $(s) return $(TARGET-CXX-REPO) ] ;
 547
 548         if ! $(r) in [ on $(targets[1]) return $(CXX-REPOS) ]
 549         {
 550             CXX-REPOS on $(targets[1]) += $(r) ;
 551         }
 552     }
 553
 554     if [ on $(targets[1]) return $(CXX-REPOS) ]
 555     {
 556         CXX-REPO-OBJS on $(targets[1]) = [ on $(targets[1]) return [ vms-join-wildcard-name $(CXX-REPOS:W) : *$(.OBJ) ] ] ;
 557
 558         #DEPENDS $(targets) : [ on $(targets[1]) return $(CXX-REPO-OBJS) ] ;
 559     }
 560 }
 561
 562 # Declare action for creating static libraries
 563 actions piecemeal archive
 564 {
 565     HAVE_REPO_OBJS = "F"
 566     IF ("" +"$(CXX-REPO-OBJS[1])" .NES. "")
 567     THEN
 568        IF ( "" +F$SEARCH("$(CXX-REPO-OBJS[1])") .NES. "")
 569        THEN
 570           HAVE_REPO_OBJS = "T"
 571        ENDIF
 572     ENDIF
 573     $(.AR) /CREATE /REPL $(AROPTIONS) $(<:W) $(>:WJ=,)
 574     IF (HAVE_REPO_OBJS)
 575     THEN
 576         $(.AR) /REPL $(AROPTIONS) $(<:W) $(CXX-REPO-OBJS:J=,)
 577         PIPE DEL /NOLOG /NOCONF $(CXX-REPO-OBJS:J=;*,);* 2>NL: >NL:
 578     ENDIF
 579 }
 580