commit e6f8202f5050f047e12b49c31cf4f6ede7ec6c24 Author: Adrien Destugues Date: Thu Nov 11 12:37:07 2021 +0100 Import Ryan's Jamfile engine This was added to the Haiku repository as part of #5360 but was never packaged. Having it in a separate repository will make it easier to package it separately at haikuports and we can include it in Haiku images this way. diff --git a/Jamfile b/Jamfile new file mode 100644 index 0000000..96e9eba --- /dev/null +++ b/Jamfile @@ -0,0 +1,119 @@ +## Haiku Generic Jamfile v1.0.1 ## + +## Fill in this file to specify the project being created, and the referenced +## Jamfile-engine will do all of the hard work for you. This handles both +## Intel and PowerPC builds of BeOS and Haiku. + +## Application Specific Settings --------------------------------------------- + +# Specify the name of the binary +# If the name has spaces, you must quote it: "My App" +NAME = ; + +# Specify the type of binary +# APP: Application +# SHARED: Shared library or add-on +# STATIC: Static library archive +# DRIVER: Kernel Driver +TYPE = ; + +# Specify the application MIME signature, if you plan to use localization +# features. String format x-vnd.- is recommended. +APP_MIME_SIG = ; + +# Specify the source files to use +# Full paths or paths relative to the Jamfile can be included. +# All files, regardless of directory, will have their object +# files created in the common object directory. +# Note that this means this Jamfile will not work correctly +# if two source files with the same name (source.c or source.cpp) +# are included from different directories. +# Ex: SRCS = file1.cpp file2.cpp file3.cpp ; +SRCS = ; + +# Specify the resource files to use +# Full path or a relative path to the resource file can be used. +RSRCS = ; + +# Specify additional libraries to link against +# There are two acceptable forms of library specifications +# - if your library follows the naming pattern of: +# libXXX.so or libXXX.a you can simply specify XXX +# library: libbe.so entry: be +# +# - for localization support add following libs: +# locale localestub +# +# - if your library does not follow the standard library +# naming scheme you need to specify the path to the library +# and it's name +# library: my_lib.a entry: my_lib.a or path/my_lib.a +LIBS = ; + +# Specify additional paths to directories following the standard +# libXXX.so or libXXX.a naming scheme. You can specify full paths +# or paths relative to the Jamfile. The paths included may not +# be recursive, so include all of the paths where libraries can +# be found. Directories where source files are found are +# automatically included. +LIBPATHS = ; + +# Additional paths to look for system headers +# These use the form: #include
+# source file directories are NOT auto-included here +SYSTEM_INCLUDE_PATHS = ; + +# Additional paths to look for local headers +# thes use the form: #include "header" +# source file directories are automatically included +LOCAL_INCLUDE_PATHS = ; + +# Specify the level of optimization that you desire +# NONE, SOME, FULL +OPTIMIZE = ; + +# Specify the codes for languages you are going to support in this +# application. The default "en" one must be provided too. "jam catkeys" +# will recreate only locales/en.catkeys file. Use it as template for +# creating other languages catkeys. All localization files must be +# placed in "locales" sub-directory. +LOCALES = ; + +# Specify any preprocessor symbols to be defined. The symbols will not +# have their values set automatically; you must supply the value (if any) +# to use. For example, setting DEFINES to "DEBUG=1" will cause the +# compiler option "-DDEBUG=1" to be used. Setting DEFINES to "DEBUG" +# would pass "-DDEBUG" on the compiler's command line. +DEFINES = ; + +# Specify special warning levels +# if unspecified default warnings will be used +# NONE = supress all warnings +# ALL = enable all warnings +WARNINGS = ; + +# Specify whether image symbols will be created +# so that stack crawls in the debugger are meaningful +# if TRUE symbols will be created +SYMBOLS = ; + +# Specify debug settings +# if TRUE will allow application to be run from a source-level +# debugger. Note that this will disable all optimzation. +DEBUGGER = ; + +# Specify additional compiler flags for all files +COMPILER_FLAGS = ; + +# Specify additional linker flags +LINKER_FLAGS = ; + +# (for TYPE == DRIVER only) Specify desired location of driver in the /dev +# hierarchy. Used by the driverinstall rule. E.g., DRIVER_PATH = video/usb will +# instruct the driverinstall rule to place a symlink to your driver's binary in +# ~/add-ons/kernel/drivers/dev/video/usb, so that your driver will appear at +# /dev/video/usb when loaded. Default is "misc". +DRIVER_PATH = ; + +## Include the Jamfile-engine +include $(BUILDHOME)/etc/Jamfile-engine ; diff --git a/Jamfile-engine b/Jamfile-engine new file mode 100644 index 0000000..86c6c3f --- /dev/null +++ b/Jamfile-engine @@ -0,0 +1,481 @@ +## Haiku Generic Jamfile Engine v1.0.2 +## Does all the hard work for the Generic Jamfile +## which simply defines the project parameters. +## Most of the real work is done in the Jambase +## embedded into the jam executable. +## +## Inspired by the Be Makefile Engine +## +## Supports Generic Jamfile v1.0.1 +## +## Copyright (c) 2002-2010 Ryan Leavengood +## Copyright (c) 2011 Peter Poláčik +## Released under the Terms of the MIT License, see +## http://www.opensource.org/licenses/mit-license.html + +##------------------------------------------------------------------- +## Define some utility rules +##------------------------------------------------------------------- + +# AddResources : ; +# Adds the given resources to the given application. +rule AddResources +{ + Depends $(<) : $(>) ; +} + +actions AddResources +{ + $(XRES) -o "$(<)" $(>) +} + +# MimeSet ; +# Sets the mime type of the given application to be an application. +actions MimeSet +{ + $(MIMESET) -f "$(<)" +} + +# ProcessLibs ; +# Prepends -l to any library names that aren't _APP_ or _KERNEL_ or +# that don't have .a or .so file extensions. The result will be given +# to the linker so that it links to the right libraries. +rule ProcessLibs +{ + local result ; + for i in $(1) + { + if ( ( $(i) in _APP_ _KERNEL_ ) || ( $(i:S) in .so .a ) ) + { + result += $(i) ; + } + else + { + result += -l$(i) ; + } + } + return $(result) ; +} + +# MkObjectDirs ; +# Makes the necessary sub-directories in the object target directory based +# on the sub-directories used for the source files. +rule MkObjectDirs +{ + local dir ; + for i in $(1) + { + dir = [ FDirName $(LOCATE_TARGET) $(i:D) ] ; + Depends $(i:S=$(SUFOBJ)) : $(dir) ; + MkDir $(dir) ; + } +} + +# CollectCatKeys : ; +# Collects catalog keys for localization from sources into per-locale files +rule CollectCatKeys +{ + Depends $(<) : $(>) ; + Depends $(<) : $(LOCATE_TARGET) ; + #Depends $(<) : $(SRCS) ; + Depends $(CATKEYS_DIR)/en.catkeys : $(<) ; +} + +actions CollectCatKeys +{ + cat $(SRCS) | gcc -E -x c++ $(HDRS) $(CCFLAGS) \ + -DB_COLLECTING_CATKEYS - > $(LOCATE_TARGET)/$(NAME).pre + mkdir -p "$(CATKEYS_DIR)" + collectcatkeys -s $(APP_MIME_SIG) $(LOCATE_TARGET)/$(NAME).pre \ + -o $(CATKEYS_DIR)/en.catkeys +} + +# Catalogs : ; +# Compiles .catkeys files into .catalog files, one per locale +rule Catalogs +{ + Depends $(<) : $(>) ; + Depends $(<) : $(SRCS) ; + for lng in $(LOCALES) + { + Depends $(<) : $(CATKEYS_DIR)/$(lng:S=.catkeys) ; + Depends $(CATKEYS_DIR)/$(lng:S=.catkeys) : $(>) ; + #Clean clean : $(CATKEYS_DIR)/$(lng:S=.catkeys) ; + Clean clean : + $(LOCATE_TARGET)/$(APP_MIME_SIG)/$(lng:S=.catalog) ; + } + Clean clean : $(LOCATE_TARGET)/$(NAME).pre ; +} + +actions Catalogs +{ + mkdir -p $(LOCATE_TARGET)/$(APP_MIME_SIG) + TMP=`echo "$(LOCALES)" | tr ';' ' '` + + for lang in $TMP ; do + if [ ! -f $(CATKEYS_DIR)/$lang.catkeys ]; then + cp $(CATKEYS_DIR)/en.catkeys \ + $(CATKEYS_DIR)/$lang.catkeys; fi + linkcatkeys \ + -o $(LOCATE_TARGET)/$(APP_MIME_SIG)/$lang.catalog \ + -s $(APP_MIME_SIG) \ + -l `basename $(LOCATE_TARGET)/$(APP_MIME_SIG)/$lang.catalog` \ + $(CATKEYS_DIR)/$lang.catkeys + done +} + +# CatalogsInstall : ; +# Copies .catalog files into system locale directory +rule CatalogsInstall +{ + Depends $(<) : $(>) ; + Depends $(>) : catalogs ; +} + +actions CatalogsInstall +{ + mkdir -p "/boot/home/config/data/locale/catalogs/$(APP_MIME_SIG)" ; + cp $(LOCATE_TARGET)/$(APP_MIME_SIG)/*.catalog \ + /boot/home/config/data/locale/catalogs/$(APP_MIME_SIG) +} + +# BindCatalogs : ; +# Binds .catalog files into program executable +rule BindCatalogs +{ + Depends $(<) : $(>) ; + Depends $(<) : $(NAME) ; + Depends $(<) : $(LOCATE_TARGET)/$(NAME) ; + Depends $(LOCATE_TARGET)/$(NAME) : $(NAME) ; + Clean clean : $(<) ; +} + +actions BindCatalogs +{ + TMP=`echo $(LOCALES) | tr ';' ' '` + for lc in $TMP; do + linkcatkeys -o $(LOCATE_TARGET)/$(NAME) \ + -s $(APP_MIME_SIG) -tr \ + -l $lc $(CATKEYS_DIR)/$lc.catkeys + done +} + +# RmApp : ; +# Removes the given application file when the given pseudotarget +# is specified. +rule RmApp +{ + Depends $(<) : $(>) ; +} + +actions RmApp +{ + rm -rf "$(>)" +} + +# RunApp : ; +# Runs the given application in the background when the given pseudotarget +# is specified. +rule RunApp +{ + Depends $(<) : $(>) ; +} + +actions RunApp +{ + "$(>)" & +} + +# InstallDriver1 : ; +# Installs the given driver in the correct location when the given pseudotarget +# is specified. +rule InstallDriver1 +{ + Depends $(<) : $(>) ; + USER_BIN_PATH = /boot/home/config/add-ons/kernel/drivers/bin ; + USER_DEV_PATH = /boot/home/config/add-ons/kernel/drivers/dev ; +} + +actions InstallDriver1 +{ + copyattr --data "$(>)" "$(USER_BIN_PATH)/$(>:B)" + mkdir -p $(USER_DEV_PATH)/$(DRIVER_PATH) + ln -sf "$(USER_BIN_PATH)/$(>:B)" "$(USER_DEV_PATH)/$(DRIVER_PATH)/$(>:B)" +} + +# InstallDriver : ; +# Installs the given driver in the correct location when the given pseudotarget +# is specified, after making sure that this is actually a driver. +rule InstallDriver +{ + if ( $(TYPE) = DRIVER ) + { + InstallDriver1 $(<) : $(>) ; + } +} + +# Link : ; +# Replaces the actions for the default Jam Link rule with one that handles spaces +# in application names. +actions Link bind NEEDLIBS +{ + $(LINK) $(LINKFLAGS) -o "$(<)" $(UNDEFS) $(>) $(NEEDLIBS) $(LINKLIBS) +} + +# BeMain : ; +# This is the main rule that builds the project. +rule BeMain +{ + MkObjectDirs $(>) ; + + if ( $(TYPE) = STATIC ) + { + Library $(<) : $(>) ; + } + else + { + Main $(<) : $(>) ; + } + + if ( $(RSRCS) ) + { + AddResources $(<) : $(RSRCS) ; + } + + if ( $(LOCALES) ) + { + CollectCatKeys ; + } + + MimeSet $(<) ; +} + +##------------------------------------------------------------------- +## Now all the needed variables are defined +##------------------------------------------------------------------- + +# Set the directory where object files and binaries will be created. +# The pre-defined Jam variable OSPLAT will indicate what platform we +# are on (X86 vs PPC, etc.) +LOCATE_TARGET = obj.$(OSPLAT) ; + +# Set some defaults +if ( ! $(NAME) ) +{ + ECHO "No NAME defined!" ; + NAME = NameThisApp ; +} + +if ( ! $(TYPE) ) +{ + ECHO "No TYPE defined...defaulting to APP" ; + TYPE = APP ; +} + +if ( ! $(SRCS) ) +{ + ECHO "NO SRCS defined...defaulting to *.cpp in current directory" ; + SRCS = [ GLOB . : *.cpp ] ; +} + +if ( ! $(DRIVER_PATH) ) +{ + DRIVER_PATH = misc ; +} + +# Now handle platform-specific settings +if ( $(OSPLAT) = X86 ) +{ + if ( $(TYPE) = DRIVER ) + { + CCFLAGS += -D_KERNEL_MODE=1 -no-fpic ; + C++FLAGS += -D_KERNEL_MODE=1 -no-fpic ; + } + + switch $(OPTIMIZE) + { + case FULL : OPTIMIZER = -O3 ; + case SOME : OPTIMIZER = -O1 ; + case NONE : OPTIMIZER = -O0 ; + # Default to FULL + case * : OPTIMIZER = -O3 ; + } + + DEBUG = ; + + if ( $(DEBUGGER) = TRUE ) + { + DEBUG += -g ; + OPTIMIZER = -O0 ; + } + + CCFLAGS += $(OPTIMIZER) $(DEBUG) ; + C++FLAGS += $(OPTIMIZER) $(DEBUG) ; + + if ( $(WARNINGS) = ALL ) + { + CCFLAGS += -Wall -Wno-multichar -Wno-ctor-dtor-privacy ; + C++FLAGS += -Wall -Wno-multichar -Wno-ctor-dtor-privacy ; + } + else if ( $(WARNINGS) = NONE ) + { + CCFLAGS += -w ; + C++FLAGS += -w ; + } + + LINKFLAGS += $(DEBUG) ; + + # Set linker flags + switch $(TYPE) + { + case APP : LINKFLAGS += -Xlinker -soname=_APP_ ; + case SHARED : LINKFLAGS += -shared -Xlinker -soname=$(NAME) ; + case DRIVER : LINKFLAGS += -nostdlib /boot/develop/lib/x86/_KERNEL_ ; + } +} +else if ( $(OSPLAT) = PPC ) +{ + switch $(OPTIMIZE) + { + case FULL : OPTIMIZER = -O7 ; + case SOME : OPTIMIZER = -O3 ; + case NONE : OPTIMIZER = -O0 ; + # Default to FULL + case * : OPTIMIZER = -O7 ; + } + + DEBUG = ; + + if ( $(DEBUGGER) = TRUE ) + { + DEBUG += -g ; + } + + CCFLAGS += $(OPTIMIZER) $(DEBUG) ; + C++FLAGS += $(OPTIMIZER) $(DEBUG) ; + + if ( $(WARNINGS) = ALL ) + { + CCFLAGS += -w on -requireprotos ; + C++FLAGS += -w on -requireprotos ; + } + else if ( $(WARNINGS) = NONE ) + { + CCFLAGS += -w off ; + C++FLAGS += -w off ; + } + + # Clear the standard environment variable + # Now there are no standard libraries to link against + BELIBFILES = ; + + # Set linker flags + if ( $(TYPE) = SHARED ) + { + LINKFLAGS += -xms ; + } + + if ( $(TYPE) = DRIVER ) + { + LINKFLAGS += -nodefaults -export all -G + /boot/develop/lib/ppc/glue-noinit.a + /boot/develop/lib/ppc/_KERNEL_ ; + } + else + { + LINKFLAGS += -export pragma -init _init_routine_ + -term _term_routine_ -lroot + /boot/develop/lib/ppc/glue-noinit.a + /boot/develop/lib/ppc/init_term_dyn.o + /boot/develop/lib/ppc/start_dyn.o ; + } + + if ( $(SYMBOLS) = TRUE ) + { + LINKFLAGS += -map $(NAME).xMAP ; + } + + if ( $(DEBUGGER) = TRUE ) + { + LINKFLAGS += -g -osym $(NAME).SYM ; + } +} +else +{ + EXIT "Your platform is unsupported" ; +} + +# Handle the other settings +LINKLIBS += [ ProcessLibs $(LIBS) ] ; +for i in $(LIBPATHS) +{ + LINKFLAGS += -L$(i) ; +} +HDRS += $(SYSTEM_INCLUDE_PATHS) ; +HDRS += $(LOCAL_INCLUDE_PATHS) ; +CCFLAGS += $(COMPILER_FLAGS) ; +C++FLAGS += $(COMPILER_FLAGS) ; +LINKFLAGS += $(LINKER_FLAGS) ; + +# Localization specific variables + +if ( ! $(APP_MIME_SIG) ) +{ + ECHO "No mime signature defined! Defaulting to x.vnd-Haiku-$(NAME)" ; + APP_MIME_SIG = x.vnd-Haiku-$(NAME) ; +} + +CATKEYS_DIR = locales ; +if ( $(APP_MIME_SIG) ) +{ + CATALOGS_DIR = $(LOCATE_TARGET)/$(APP_MIME_SIG) ; + CATALOGS = $(LOCALES:D=$(CATALOGS_DIR):S=.catalog) ; +} + +# Define some tools +XRES = xres ; +MIMESET = mimeset ; + +# Defining this variable keeps objects from being deleted by the Library +# rule. By default the objects are deleted after being archived into +# the library. I prefer they not be. +KEEPOBJS = true ; + +# Set up the driverinstall target...this makes it easy to install drivers +# for testing +Always driverinstall ; +NotFile driverinstall ; +InstallDriver driverinstall : $(NAME) ; + +# Set up the rmapp target...this removes only the application +Always rmapp ; +NotFile rmapp ; +RmApp rmapp : $(NAME) ; + +# Set up the test target...this runs the application in the background +#Always test ; +NotFile test ; +RunApp test : $(NAME) ; + +Always catkeys ; +NotFile catkeys ; +CollectCatKeys catkeys : $(SRCS) ; + +#Always catalogs ; +NotFile catalogs ; +Catalogs catalogs : catkeys ; + +#Always catalogsinstall ; +NotFile catalogsinstall ; +CatalogsInstall catalogsinstall : $(CATALOGS_DIR)/$(LOCALES:S=.catalog) ; + +#Always bindcatalogs ; +NotFile bindcatalogs ; +BindCatalogs bindcatalogs : $(CATALOGS_DIR)/$(LOCALES:S=.catalog) ; + +##------------------------------------------------------------------- +## OK, let's build +##------------------------------------------------------------------- + +BeMain $(NAME) : $(SRCS) ; +