data/develop/Jamfile-engine

   1 ##      Haiku Generic Jamfile Engine v1.0.2
   2 ##      Does all the hard work for the Generic Jamfile
   3 ##      which simply defines the project parameters.
   4 ##      Most of the real work is done in the Jambase
   5 ##      embedded into the jam executable.
   6 ##
   7 ##      Inspired by the Be Makefile Engine
   8 ##
   9 ##      Supports Generic Jamfile v1.0.1
  10 ##
  11 ##      Copyright (c) 2002-2010 Ryan Leavengood
  12 ##      Copyright (c) 2011 Peter Poláčik
  13 ##      Released under the Terms of the MIT License, see
  14 ##      http://www.opensource.org/licenses/mit-license.html
  15
  16 ##-------------------------------------------------------------------
  17 ## Define some utility rules
  18 ##-------------------------------------------------------------------
  19
  20 # AddResources <Application Name> : <Resource Files> ;
  21 #   Adds the given resources to the given application.
  22 rule AddResources
  23 {
  24         Depends $(<) : $(>) ;
  25 }
  26
  27 actions AddResources
  28 {
  29         $(XRES) -o "$(<)" $(>)
  30 }
  31
  32 # MimeSet <Application Name> ;
  33 #   Sets the mime type of the given application to be an application.
  34 actions MimeSet
  35 {
  36         $(MIMESET) -f "$(<)"
  37 }
  38
  39 # ProcessLibs <List of Library Names> ;
  40 #   Prepends -l to any library names that aren't _APP_ or _KERNEL_ or
  41 #   that don't have .a or .so file extensions.  The result will be given
  42 #   to the linker so that it links to the right libraries.
  43 rule ProcessLibs
  44 {
  45         local result ;
  46         for i in $(1)
  47         {
  48                 if ( ( $(i) in _APP_ _KERNEL_ ) || ( $(i:S) in .so .a ) )
  49                 {
  50                         result += $(i) ;
  51                 }
  52                 else
  53                 {
  54                         result += -l$(i) ;
  55                 }
  56         }
  57         return $(result) ;
  58 }
  59
  60 # MkObjectDirs <List of Source Files> ;
  61 #   Makes the necessary sub-directories in the object target directory based
  62 #   on the sub-directories used for the source files.
  63 rule MkObjectDirs
  64 {
  65         local dir ;
  66         for i in $(1)
  67         {
  68                 dir = [ FDirName $(LOCATE_TARGET) $(i:D) ] ;
  69                 Depends $(i:S=$(SUFOBJ)) : $(dir) ;
  70                 MkDir $(dir) ;
  71         }
  72 }
  73
  74 # CollectCatKeys <Pseudotarget Name> : <Source Files> ;
  75 #   Collects catalog keys for localization from sources into per-locale files
  76 rule CollectCatKeys
  77 {
  78         Depends $(<) : $(>) ;
  79         Depends $(<) : $(LOCATE_TARGET) ;
  80         #Depends $(<) : $(SRCS) ;
  81         Depends $(CATKEYS_DIR)/en.catkeys : $(<) ;
  82 }
  83
  84 actions CollectCatKeys
  85 {
  86         cat $(SRCS) | gcc -E -x c++ $(HDRS) $(CCFLAGS) \
  87                 -DB_COLLECTING_CATKEYS - > $(LOCATE_TARGET)/$(NAME).pre
  88         mkdir -p "$(CATKEYS_DIR)"
  89         collectcatkeys -s $(APP_MIME_SIG) $(LOCATE_TARGET)/$(NAME).pre \
  90                 -o $(CATKEYS_DIR)/en.catkeys
  91 }
  92
  93 # Catalogs <Pseudotarget Name> : <CollectCatKeys Target> ;
  94 #    Compiles .catkeys files into .catalog files, one per locale
  95 rule Catalogs
  96 {
  97         Depends $(<) : $(>) ;
  98         Depends $(<) : $(SRCS) ;
  99         for lng in $(LOCALES)
 100         {
 101                 Depends $(<) : $(CATKEYS_DIR)/$(lng:S=.catkeys) ;
 102                 Depends $(CATKEYS_DIR)/$(lng:S=.catkeys) : $(>) ;
 103                 #Clean clean : $(CATKEYS_DIR)/$(lng:S=.catkeys) ;
 104                 Clean clean :
 105                         $(LOCATE_TARGET)/$(APP_MIME_SIG)/$(lng:S=.catalog) ;
 106         }
 107         Clean clean : $(LOCATE_TARGET)/$(NAME).pre ;
 108 }
 109
 110 actions Catalogs
 111 {
 112         mkdir -p $(LOCATE_TARGET)/$(APP_MIME_SIG)
 113         TMP=`echo "$(LOCALES)" | tr ';' ' '`
 114
 115         for lang in $TMP ; do
 116                 if [ ! -f $(CATKEYS_DIR)/$lang.catkeys ]; then
 117                         cp $(CATKEYS_DIR)/en.catkeys \
 118                                 $(CATKEYS_DIR)/$lang.catkeys; fi
 119                 linkcatkeys \
 120                 -o $(LOCATE_TARGET)/$(APP_MIME_SIG)/$lang.catalog \
 121                 -s $(APP_MIME_SIG) \
 122                 -l `basename $(LOCATE_TARGET)/$(APP_MIME_SIG)/$lang.catalog` \
 123                 $(CATKEYS_DIR)/$lang.catkeys
 124         done
 125 }
 126
 127 # CatalogsInstall <Pseudotarget Name> : <Catalog Files> ;
 128 #    Copies .catalog files into system locale directory
 129 rule CatalogsInstall
 130 {
 131         Depends $(<) : $(>) ;
 132         Depends $(>) : catalogs ;
 133 }
 134
 135 actions CatalogsInstall
 136 {
 137         mkdir -p "/boot/home/config/data/locale/catalogs/$(APP_MIME_SIG)" ;
 138         cp $(LOCATE_TARGET)/$(APP_MIME_SIG)/*.catalog \
 139         /boot/home/config/data/locale/catalogs/$(APP_MIME_SIG)
 140 }
 141
 142 # BindCatalogs <Pseudotarget Name> : <Catalog Files> ;
 143 #    Binds .catalog files into program executable
 144 rule BindCatalogs
 145 {
 146         Depends $(<) : $(>) ;
 147         Depends $(<) : $(NAME) ;
 148         Depends $(<) : $(LOCATE_TARGET)/$(NAME) ;
 149         Depends $(LOCATE_TARGET)/$(NAME) : $(NAME) ;
 150         Clean clean : $(<) ;
 151 }
 152
 153 actions BindCatalogs
 154 {
 155         TMP=`echo $(LOCALES) | tr ';' ' '`
 156         for lc in $TMP; do
 157                 linkcatkeys -o $(LOCATE_TARGET)/$(NAME) \
 158                 -s $(APP_MIME_SIG) -tr \
 159                 -l $lc $(CATKEYS_DIR)/$lc.catkeys
 160         done
 161 }
 162
 163 # RmApp <Pseudotarget Name> : <Application Name> ;
 164 #   Removes the given application file when the given pseudotarget
 165 #   is specified.
 166 rule RmApp
 167 {
 168         Depends $(<) : $(>) ;
 169 }
 170
 171 actions RmApp
 172 {
 173         rm -rf "$(>)"
 174 }
 175
 176 # RunApp <Pseudotarget Name> : <Application Name> ;
 177 #   Runs the given application in the background when the given pseudotarget
 178 #   is specified.
 179 rule RunApp
 180 {
 181         Depends $(<) : $(>) ;
 182 }
 183
 184 actions RunApp
 185 {
 186         "$(>)" &
 187 }
 188
 189 # InstallDriver1 <Pseudotarget Name> : <Driver File> ;
 190 #   Installs the given driver in the correct location when the given pseudotarget
 191 #   is specified.
 192 rule InstallDriver1
 193 {
 194         Depends $(<) : $(>) ;
 195         USER_BIN_PATH = /boot/home/config/add-ons/kernel/drivers/bin ;
 196         USER_DEV_PATH = /boot/home/config/add-ons/kernel/drivers/dev ;
 197 }
 198
 199 actions InstallDriver1
 200 {
 201         copyattr --data "$(>)" "$(USER_BIN_PATH)/$(>:B)"
 202         mkdir -p $(USER_DEV_PATH)/$(DRIVER_PATH)
 203         ln -sf "$(USER_BIN_PATH)/$(>:B)" "$(USER_DEV_PATH)/$(DRIVER_PATH)/$(>:B)"
 204 }
 205
 206 # InstallDriver <Pseudotarget Name> : <Driver File> ;
 207 #   Installs the given driver in the correct location when the given pseudotarget
 208 #   is specified, after making sure that this is actually a driver.
 209 rule InstallDriver
 210 {
 211         if ( $(TYPE) = DRIVER )
 212         {
 213                 InstallDriver1 $(<) : $(>) ;
 214         }
 215 }
 216
 217 # Link <Application Name> : <List of Object Files> ;
 218 #   Replaces the actions for the default Jam Link rule with one that handles spaces
 219 #   in application names.
 220 actions Link bind NEEDLIBS
 221 {
 222         $(LINK) $(LINKFLAGS) -o "$(<)" $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS)
 223 }
 224
 225 # BeMain <Application Name> : <List of Source Files> ;
 226 #   This is the main rule that builds the project.
 227 rule BeMain
 228 {
 229         MkObjectDirs $(>) ;
 230
 231         if ( $(TYPE) = STATIC )
 232         {
 233                 Library $(<) : $(>) ;
 234         }
 235         else
 236         {
 237                 Main $(<) : $(>) ;
 238         }
 239
 240         if ( $(RSRCS) )
 241         {
 242                 AddResources $(<) : $(RSRCS) ;
 243         }
 244
 245         if ( $(LOCALES) )
 246         {
 247                 CollectCatKeys ;
 248         }
 249
 250         MimeSet $(<) ;
 251 }
 252
 253 ##-------------------------------------------------------------------
 254 ## Now all the needed variables are defined
 255 ##-------------------------------------------------------------------
 256
 257 # Set the directory where object files and binaries will be created.
 258 # The pre-defined Jam variable OSPLAT will indicate what platform we
 259 # are on (X86 vs PPC, etc.)
 260 LOCATE_TARGET = obj.$(OSPLAT) ;
 261
 262 # Set some defaults
 263 if ( ! $(NAME) )
 264 {
 265         ECHO "No NAME defined!" ;
 266         NAME = NameThisApp ;
 267 }
 268
 269 if ( ! $(TYPE) )
 270 {
 271         ECHO "No TYPE defined...defaulting to APP" ;
 272         TYPE = APP ;
 273 }
 274
 275 if ( ! $(SRCS) )
 276 {
 277         ECHO "NO SRCS defined...defaulting to *.cpp in current directory" ;
 278         SRCS = [ GLOB . : *.cpp ] ;
 279 }
 280
 281 if ( ! $(DRIVER_PATH) )
 282 {
 283         DRIVER_PATH = misc ;
 284 }
 285
 286 # Now handle platform-specific settings
 287 if ( $(OSPLAT) = X86 )
 288 {
 289         if ( $(TYPE) = DRIVER )
 290         {
 291                 CCFLAGS += -D_KERNEL_MODE=1 -no-fpic ;
 292                 C++FLAGS += -D_KERNEL_MODE=1 -no-fpic ;
 293         }
 294
 295         switch $(OPTIMIZE)
 296         {
 297                 case FULL : OPTIMIZER = -O3 ;
 298                 case SOME : OPTIMIZER = -O1 ;
 299                 case NONE : OPTIMIZER = -O0 ;
 300                 # Default to FULL
 301                 case * : OPTIMIZER = -O3 ;
 302         }
 303
 304         DEBUG = ;
 305
 306         if ( $(DEBUGGER) = TRUE )
 307         {
 308                 DEBUG += -g ;
 309                 OPTIMIZER = -O0 ;
 310         }
 311
 312         CCFLAGS += $(OPTIMIZER) $(DEBUG) ;
 313         C++FLAGS += $(OPTIMIZER) $(DEBUG) ;
 314
 315         if ( $(WARNINGS) = ALL )
 316         {
 317                 CCFLAGS += -Wall -Wno-multichar -Wno-ctor-dtor-privacy ;
 318                 C++FLAGS += -Wall -Wno-multichar -Wno-ctor-dtor-privacy ;
 319         }
 320         else if ( $(WARNINGS) = NONE )
 321         {
 322                 CCFLAGS += -w ;
 323                 C++FLAGS += -w ;
 324         }
 325
 326         LINKFLAGS += $(DEBUG) ;
 327
 328         # Set linker flags
 329         switch $(TYPE)
 330         {
 331                 case APP : LINKFLAGS += -Xlinker -soname=_APP_ ;
 332                 case SHARED : LINKFLAGS += -shared -Xlinker -soname=$(NAME) ;
 333                 case DRIVER : LINKFLAGS += -nostdlib /boot/develop/lib/x86/_KERNEL_ ;
 334         }
 335 }
 336 else if ( $(OSPLAT) = PPC )
 337 {
 338         switch $(OPTIMIZE)
 339         {
 340                 case FULL : OPTIMIZER = -O7 ;
 341                 case SOME : OPTIMIZER = -O3 ;
 342                 case NONE : OPTIMIZER = -O0 ;
 343                 # Default to FULL
 344                 case * : OPTIMIZER = -O7 ;
 345         }
 346
 347         DEBUG = ;
 348
 349         if ( $(DEBUGGER) = TRUE )
 350         {
 351                 DEBUG += -g ;
 352         }
 353
 354         CCFLAGS += $(OPTIMIZER) $(DEBUG) ;
 355         C++FLAGS += $(OPTIMIZER) $(DEBUG) ;
 356
 357         if ( $(WARNINGS) = ALL )
 358         {
 359                 CCFLAGS += -w on -requireprotos ;
 360                 C++FLAGS += -w on -requireprotos ;
 361         }
 362         else if ( $(WARNINGS) = NONE )
 363         {
 364                 CCFLAGS += -w off ;
 365                 C++FLAGS += -w off ;
 366         }
 367
 368         # Clear the standard environment variable
 369         # Now there are no standard libraries to link against
 370         BELIBFILES = ;
 371
 372         # Set linker flags
 373         if ( $(TYPE) = SHARED )
 374         {
 375                 LINKFLAGS += -xms ;
 376         }
 377
 378         if ( $(TYPE) = DRIVER )
 379         {
 380                 LINKFLAGS += -nodefaults -export all -G
 381                         /boot/develop/lib/ppc/glue-noinit.a
 382                         /boot/develop/lib/ppc/_KERNEL_ ;
 383         }
 384         else
 385         {
 386                 LINKFLAGS += -export pragma -init _init_routine_
 387                         -term _term_routine_ -lroot
 388                         /boot/develop/lib/ppc/glue-noinit.a
 389                         /boot/develop/lib/ppc/init_term_dyn.o
 390                         /boot/develop/lib/ppc/start_dyn.o ;
 391         }
 392
 393         if ( $(SYMBOLS) = TRUE )
 394         {
 395                 LINKFLAGS += -map $(NAME).xMAP ;
 396         }
 397
 398         if ( $(DEBUGGER) = TRUE )
 399         {
 400                 LINKFLAGS += -g -osym $(NAME).SYM ;
 401         }
 402 }
 403 else
 404 {
 405         EXIT "Your platform is unsupported" ;
 406 }
 407
 408 # Handle the other settings
 409 LINKLIBS += [ ProcessLibs $(LIBS) ] ;
 410 for i in $(LIBPATHS)
 411 {
 412         LINKFLAGS += -L$(i) ;
 413 }
 414 HDRS += $(SYSTEM_INCLUDE_PATHS) ;
 415 HDRS += $(LOCAL_INCLUDE_PATHS) ;
 416 CCFLAGS += $(COMPILER_FLAGS) ;
 417 C++FLAGS += $(COMPILER_FLAGS) ;
 418 LINKFLAGS += $(LINKER_FLAGS) ;
 419
 420 # Localization specific variables
 421
 422 if ( ! $(APP_MIME_SIG) )
 423 {
 424         ECHO "No mime signature defined! Defaulting to x.vnd-Haiku-$(NAME)" ;
 425         APP_MIME_SIG = x.vnd-Haiku-$(NAME) ;
 426 }
 427
 428 CATKEYS_DIR = locales ;
 429 if ( $(APP_MIME_SIG) )
 430 {
 431         CATALOGS_DIR = $(LOCATE_TARGET)/$(APP_MIME_SIG) ;
 432         CATALOGS = $(LOCALES:D=$(CATALOGS_DIR):S=.catalog) ;
 433 }
 434
 435 # Define some tools
 436 XRES = xres ;
 437 MIMESET = mimeset ;
 438
 439 # Defining this variable keeps objects from being deleted by the Library
 440 # rule.  By default the objects are deleted after being archived into
 441 # the library.  I prefer they not be.
 442 KEEPOBJS = true ;
 443
 444 # Set up the driverinstall target...this makes it easy to install drivers
 445 # for testing
 446 Always driverinstall ;
 447 NotFile driverinstall ;
 448 InstallDriver driverinstall : $(NAME) ;
 449
 450 # Set up the rmapp target...this removes only the application
 451 Always rmapp ;
 452 NotFile rmapp ;
 453 RmApp rmapp : $(NAME) ;
 454
 455 # Set up the test target...this runs the application in the background
 456 #Always test ;
 457 NotFile test ;
 458 RunApp test : $(NAME) ;
 459
 460 Always catkeys ;
 461 NotFile catkeys ;
 462 CollectCatKeys catkeys : $(SRCS) ;
 463
 464 #Always catalogs ;
 465 NotFile catalogs ;
 466 Catalogs catalogs : catkeys ;
 467
 468 #Always catalogsinstall ;
 469 NotFile catalogsinstall ;
 470 CatalogsInstall catalogsinstall : $(CATALOGS_DIR)/$(LOCALES:S=.catalog) ;
 471
 472 #Always bindcatalogs ;
 473 NotFile bindcatalogs ;
 474 BindCatalogs bindcatalogs : $(CATALOGS_DIR)/$(LOCALES:S=.catalog) ;
 475
 476 ##-------------------------------------------------------------------
 477 ## OK, let's build
 478 ##-------------------------------------------------------------------
 479
 480 BeMain $(NAME) : $(SRCS) ;
 481