build/jam/BeOSRules

   1 # BeOS specific rules
   2
   3 rule AddFileDataAttribute target : attrName : attrType : dataFile
   4 {
   5         # AddFileAttribute <target> : <attrName> : <attrType> : <dataFile> ;
   6         # Adds a single attribute to a file, retrieving the attribute data from
   7         # a separate file.
   8         # <target>: The file to which the attribute shall be added.
   9         # <attrName>: The name of the attribute.
  10         # <attrType>: Attribute type as supported by addattr (string, int, etc.)
  11         # <dataFile>: The data to be written to the attribute will be read from
  12         #             that file.
  13         #             Note that this is supposed to be a build target, not a path
  14         #             name - if you need to add a data file in a different path,
  15         #                         you have to locate it first.
  16         #
  17
  18         # We need to create a temporary file in which we store the attribute name
  19         # and type. Otherwise we wouldn't have these data available in the
  20         # addattr actions.
  21         local id = [ NextID ] ;
  22         local attrMetaFile
  23                 = [ FGristFiles $(target:G=)-attr-$(attrName)-$(attrType)-$(id) ] ;
  24
  25         ATTRIBUTE_NAME on $(attrMetaFile) = $(attrName) ;
  26         ATTRIBUTE_TYPE on $(attrMetaFile) = $(attrType) ;
  27         MakeLocateArch $(attrMetaFile) ;
  28         CreateAttributeMetaFile $(attrMetaFile) ;
  29
  30         Depends $(target) : <build>addattr $(attrMetaFile) $(dataFile) ;
  31         AddFileDataAttribute1 $(target)
  32                 : <build>addattr $(attrMetaFile) $(dataFile) ;
  33 }
  34
  35 actions CreateAttributeMetaFile
  36 {
  37         echo "-t $(ATTRIBUTE_TYPE)" "$(ATTRIBUTE_NAME)" > "$(1)"
  38 }
  39
  40 actions AddFileDataAttribute1
  41 {
  42         $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
  43         $(2[1]) -f $(2[3]) `cat $(2[2])` $(1)
  44 }
  45
  46 rule AddStringDataResource
  47 {
  48         # AddStringDataResource <target> : <resourceID> : <dataString>
  49         # Adds a single resource to the resources of an executable/library.
  50         # <target>: The executable/library.
  51         # <resourceID>: A resource ID string as understood by xres (type:id[:name]).
  52         # <dataString>: The string <dataString> will be written to the resource.
  53         #               Defaults to "".
  54         #
  55         local target = $(1) ;
  56         local resourceID = $(2) ;
  57         local dataString = $(3:E="") ;
  58
  59         # the resource file
  60         local resources
  61                 = [ FGristFiles $(target:B)-added-string-data-resources.rsrc ] ;
  62
  63         # add the resource file to the target, if not yet done
  64         if ! [ on $(resources) return $(RESOURCES_ADDED) ] {
  65                 RESOURCES_ADDED on $(resources) = true ;
  66                 MakeLocateArch $(resources) ;
  67                 Depends $(resources) : <build>xres ;
  68                 AddStringDataResource1 $(resources) : <build>xres ;
  69                 AddResources $(target) : $(resources) ;
  70         }
  71
  72         RESOURCE_STRINGS on $(resources)
  73                 += "-a "$(resourceID)" -s \""$(dataString)"\"" ;
  74 }
  75
  76 actions together AddStringDataResource1
  77 {
  78         $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
  79         $(2[1]) -o "$(1)" $(RESOURCE_STRINGS)
  80 }
  81
  82 rule AddFileDataResource
  83 {
  84         # AddFileDataResource <target> : <resourceID> : [ <dataFile> ]
  85         # Adds a single resource to the resources of an executable/library.
  86         # <target>: The executable/library.
  87         # <resourceID>: A resource ID string as understood by xres (type:id[:name]).
  88         # <dataFile>: The data to be written into the resource will be read from
  89         #             that file.
  90         #             Note that this is supposed to be a build target, not a path
  91         #             name - if you need to add a data file in a different path, you
  92         #             have to locate it first.
  93         #
  94         local target = $(1) ;
  95         local resourceID = $(2) ;
  96         local dataFile = $(3) ;
  97
  98         # the resource file
  99         local resources
 100                 = <added-resources>file-data-$(resourceID)-$(dataFile).rsrc ;
 101
 102         # add it to the resources of the given target
 103         AddResources $(target) : $(resources) ;
 104
 105         # if the rule for creating the resource file has not been invoked yet, do it
 106         if ! [ on $(resources) return $(RESOURCES_DEFINED) ] {
 107                 RESOURCES_DEFINED on $(resources) = true ;
 108                 RESOURCE_ID on $(resources) = $(resourceID) ;
 109                 MakeLocateArch $(resources) ;
 110
 111                 Depends $(resources) : <build>xres $(dataFile) ;
 112                 AddFileDataResource1 $(resources) : <build>xres $(dataFile) ;
 113         }
 114 }
 115
 116 actions AddFileDataResource1
 117 {
 118         $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
 119         $(2[1]) -o "$(1)" -a "$(RESOURCE_ID)" "$(2[2])" ;
 120 }
 121
 122 rule XRes
 123 {
 124         # XRes <target> : <resource files>
 125         if $(2)
 126         {
 127                 Depends $(1) : <build>xres $(2) ;
 128                 XRes1 $(1) : <build>xres $(2) ;
 129         }
 130 }
 131
 132 actions XRes1
 133 {
 134         $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
 135         $(2[1]) -o "$(1)" "$(2[2-])" ;
 136 }
 137
 138 rule SetVersion
 139 {
 140         # SetVersion <target>
 141
 142         Depends $(1) : <build>setversion ;
 143         SetVersion1 $(1) : <build>setversion ;
 144 }
 145
 146 actions SetVersion1
 147 {
 148         $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
 149         $(2[1]) "$(1)" -system $(HAIKU_BUILD_VERSION) -short "$(HAIKU_BUILD_DESCRIPTION)" ;
 150 }
 151
 152 rule SetType target : type
 153 {
 154         # SetType <target> [ : <type> ]
 155         # Sets the MIME type on the target. If none is given, the executable MIME
 156         # type is used.
 157
 158         TARGET_MIME_TYPE on $(target) = $(type:E=$(TARGET_EXECUTABLE_MIME_TYPE)) ;
 159
 160         Depends $(target) : <build>settype ;
 161         SetType1 $(target) : <build>settype ;
 162 }
 163
 164 actions SetType1
 165 {
 166         $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
 167         $(2[1]) -t $(TARGET_MIME_TYPE) "$(1)" ;
 168 }
 169
 170 rule MimeSet target
 171 {
 172         # MimeSet <target> ;
 173
 174         Depends $(target) : <build>mimeset <mimedb>mime_db ;
 175         MimeSet1 $(target) : <build>mimeset <mimedb>mime_db ;
 176 }
 177
 178
 179 actions MimeSet1
 180 {
 181         $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
 182         $(2[1]) -f --mimedb "$(2[2])" "$(1)"
 183 }
 184
 185
 186 rule CreateAppMimeDBEntries target
 187 {
 188         # MimeSetApp <target> ;
 189         # Create the app meta MIME DB entries for the given target. The
 190         # HAIKU_MIME_DB_ENTRIES variable on <target> is set to the generated
 191         # resulting target directory that contains the MIME DB entries.
 192
 193         local appGrist = $(target:G) ;
 194         local appMimeDB = $(target:BS)_mimedb ;
 195         appMimeDB = $(appMimeDB:G=mimedb-app-$(appGrist:E=)) ;
 196         MakeLocateDebug $(appMimeDB) ;
 197         Depends $(appMimeDB) : <build>mimeset $(target) <mimedb>mime_db ;
 198         CreateAppMimeDBEntries1 $(appMimeDB)
 199                 : <build>mimeset $(target) <mimedb>mime_db ;
 200
 201         HAIKU_MIME_DB_ENTRIES on $(target) = $(appMimeDB) ;
 202 }
 203
 204
 205 actions CreateAppMimeDBEntries1
 206 {
 207         $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
 208
 209         appMimeDB="$(1)"
 210         $(RM) -rf "$appMimeDB"
 211         $(MKDIR) "$appMimeDB"
 212         $(2[1]) -f --apps --mimedb "$appMimeDB" --mimedb "$(2[3])" "$(2[2])"
 213 }
 214
 215
 216 rule ResComp
 217 {
 218         # ResComp <resource file> : <rdef file> ;
 219         #
 220         # <resource file> and <rdef file> must be gristed.
 221
 222         # get compiler and defines for the platform
 223         local cc ;
 224         local defines ;
 225         local localIncludesOption ;
 226
 227         on $(1) { # use on $(1) variable values
 228                 defines = $(DEFINES) ;
 229
 230                 if $(PLATFORM) = host {
 231                         defines += $(HOST_DEFINES) ;
 232                         cc = $(HOST_CC) ;
 233                         localIncludesOption = $(HOST_LOCAL_INCLUDES_OPTION) ;
 234                 } else {
 235                         defines += $(TARGET_DEFINES_$(TARGET_PACKAGING_ARCH))
 236                                 $(TARGET_DEFINES) ;
 237                         cc = $(TARGET_CC_$(TARGET_PACKAGING_ARCH)) ;
 238                         localIncludesOption
 239                                 = $(TARGET_LOCAL_INCLUDES_OPTION_$(TARGET_PACKAGING_ARCH)) ;
 240                 }
 241         }
 242
 243         DEFINES on $(1) = $(defines) ;
 244         CCDEFS on $(1) = [ FDefines $(defines) ] ;
 245         HDRS on $(1) = [ FIncludes $(SEARCH_SOURCE) $(SUBDIRHDRS) $(HDRS)
 246                 : $(localIncludesOption) ] ;
 247         RCHDRS on $(1) = [ FIncludes $(SEARCH_SOURCE) $(SUBDIRHDRS) $(HDRS)
 248                 : "-I " ] ;
 249         CC on $(1) = $(cc) ;
 250
 251         # set up other vars
 252         SEARCH on $(2) += $(SEARCH_SOURCE) ;
 253         MakeLocateArch $(1) ;
 254         Depends $(1) : $(2) <build>rc ;
 255         LocalClean clean : $(1) ;
 256         ResComp1 $(1) : <build>rc $(2) ;
 257 }
 258
 259 # Note: We pipe the input files into the preprocessor, since *.rdef files are
 260 # considered linker scripts, and thus we can use preprocessor features.
 261 actions ResComp1
 262 {
 263         $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
 264         cat "$(2[2-])" | $(CC) -E $(CCDEFS) $(HDRS) - | egrep -v '^#' | $(2[1]) $(RCHDRS) --auto-names -o "$(1)" -
 265 }
 266
 267 rule ResAttr attributeFile : _resourceFiles : deleteAttributeFile
 268 {
 269         # ResAttr <attribute file> : <resource files> [ : <delete file> ] ;
 270         #
 271         # <attribute file> and <resource files> must be gristed.
 272         # <resource files> can also be .rdef files -- they will be compiled first in
 273         # this case.
 274         # <clear file> is a boolean that specifies wether or not the target file
 275         # should be removed before writing. Defaults to true.
 276
 277         local resourceFiles ;
 278         local resourceFile ;
 279         deleteAttributeFile ?= true ;
 280         deleteAttributeFile1 on $(1) = $(deleteAttributeFile) ;
 281
 282         for resourceFile in $(_resourceFiles) {
 283                 # if the specified resource file is an .rdef file, we compile it first
 284                 if $(resourceFile:S) = ".rdef" {
 285                         local rdefFile = $(resourceFile) ;
 286                         resourceFile = $(rdefFile:S=.rsrc) ;
 287                         ResComp $(resourceFile) : $(rdefFile) ;
 288                 } else {
 289                         SEARCH on $(resourceFile) += $(SEARCH_SOURCE) ;
 290                 }
 291
 292                 resourceFiles += $(resourceFile) ;
 293         }
 294
 295         MakeLocateArch $(attributeFile) ;
 296         Depends $(attributeFile) : $(resourceFiles) <build>resattr ;
 297         LocalClean clean : $(attributeFile) ;
 298         ResAttr1 $(attributeFile) : <build>resattr $(resourceFiles) ;
 299 }
 300
 301 actions ResAttr1
 302 {
 303         $(HOST_ADD_BUILD_COMPATIBILITY_LIB_DIR)
 304         if [ \\"$(deleteAttributeFile1)\\" = "true" ]; then
 305                 $(RM) $(1)
 306         fi
 307         $(2[1]) -O -o "$(1)" "$(2[2-])"
 308 }