Make.config

include $(TOP)/mk/subdirs.mk

# Detect if we're building on Linux (which means there's no Xcode)
UNAME_S:=$(shell uname -s)
ifeq ($(UNAME_S),Linux)
NO_XCODE=1
endif

# Common cURL command:
# --fail: return an exit code if the connection succeeded, but returned an HTTP error code.
# --location: follow redirects
# --connect-timeout: if a connection doesn't happen within 15 seconds, then fail (and potentially retry). This is lower than the default to not get stuck waiting for a long time in case something goes wrong (but instead retry).
# --verbose / --silent: no explanation needed.
# --show-error: show an error to the terminal even if asked to be --silent.
CURL = curl --fail --location --connect-timeout 15 $(if $(V),--verbose,--silent) --show-error
# --retry: retry download 20 times
# --retry-delay: wait 2 seconds between each retry attempt
# --retry-all-errors: ignore the definition of insanity and retry even for errors that seem like you'd get the same result (such as 404). This isn't the real purpose, because this will also retry errors that will get a different result (such as connection failures / resets), which apparently --retry doesn't cover.
CURL_RETRY = $(CURL) --retry 20 --retry-delay 2 --retry-all-errors

DOTNET_TFM=net11.0
DOTNET_MAJOR_VERSION:=$(firstword $(subst ., ,$(subst net,,$(DOTNET_TFM))))
# calculate commit distance and store it in a file so that we don't have to re-calculate it every time make is executed.

# Support for hardcoding a commit distance start offset.
#
# The default is to add X000, where X is the major .NET version: we need to
# publish different versions of our NuGets for different .NET version
# (example: we need to publish one NuGet with support for Xcode 14.3 for .NET
# 6, and another one for .NET 7) - and these need to have different versions,
# and ordered correctly (the .NET 7 version must have a higher version than
# the .NET 6 version), and ideally it would be possible to just look at the
# version to see which .NET version it's targeting. Adding X000 to the commit
# distance accomplishes all these goals (as long as the commit distance itself
# doesn't need more than 3 digits).
NUGET_VERSION_COMMIT_DISTANCE_START=$(DOTNET_MAJOR_VERSION)000
NUGET_VERSION_STABLE_COMMIT_DISTANCE_START=$(DOTNET_MAJOR_VERSION)000

-include $(TOP)/Make.config.inc
$(TOP)/Make.config.inc: $(TOP)/Make.config $(TOP)/Make.versions $(TOP)/create-make-config.sh
	$(Q) cd $(TOP) && \
		ALL_DOTNET_PLATFORMS="$(ALL_DOTNET_PLATFORMS)" \
		NUGET_VERSION_COMMIT_DISTANCE_START=$(NUGET_VERSION_COMMIT_DISTANCE_START) \
		NUGET_VERSION_STABLE_COMMIT_DISTANCE_START=$(NUGET_VERSION_STABLE_COMMIT_DISTANCE_START) \
		./create-make-config.sh

include $(TOP)/Make.versions

# These versions are used to compute the API diff between the current commit and our current stable release.
# The value is taken from the name + version of the Ref pack.
# Example: given the Ref pack "Microsoft.iOS.Ref.net8.0_17.5" with the version "17.5.8030", the value
# to write here would be the part after "Microsoft.iOS.Ref." + "/" + version: "net8.0_17.5/17.5.8030"
STABLE_NUGET_VERSION_iOS=net10.0_27.1/27.1.10018
STABLE_NUGET_VERSION_tvOS=net10.0_27.0/27.0.10742
STABLE_NUGET_VERSION_MacCatalyst=net10.0_27.0/27.0.10742
STABLE_NUGET_VERSION_macOS=net10.0_27.0/27.0.10742

PACKAGE_HEAD_REV=$(shell git rev-parse HEAD)

#
# /!\ README /!\
#
# A release branch requires updating some variables.
# This is done in Make.versions, not here.
#

ifneq ($(BUILD_SOURCEBRANCH),)
# BUILD_SOURCEBRANCH is set in Azure DevOps, so use that value if it exists
# it seems to always start with refs/heads/, so strip off that first.
CURRENT_BRANCH:=$(subst refs/heads/,,${BUILD_SOURCEBRANCH})
else ifeq ($(BRANCH_NAME),)
# BRANCH_NAME is set in Jenkins, so this is for local builds.
CURRENT_BRANCH:=$(shell git rev-parse --abbrev-ref HEAD)
else
CURRENT_BRANCH:=$(BRANCH_NAME)
endif
CURRENT_BRANCH_SED_ESCAPED:=$(subst |,\|,$(subst &,\&,$(subst $$,\$$,$(subst /,\/,$(CURRENT_BRANCH)))))
# The branch name in the nuget version has to be alphanumeric, and we follow the semantic versioning spec,
# which defines "alphanumeric" as the letters, numbers and the dash character (and nothing else).
# So here we replace all non-alphanumeric characters in the branch name with a dash.
CURRENT_BRANCH_ALPHANUMERIC:=$(shell export LANG=C; printf "%s" "$(CURRENT_BRANCH)" | tr -c '[a-zA-Z0-9-]' '-')

# Set proper path for git directory
# If the repo is checked out as a worktree, the default .git/ does not exist,
# instead there is a .git file containing the path to the correct .git/
GIT_DIRECTORY:=$(TOP)/.git
ALTERNATIVE_GIT:=$(shell sed -n 's/^ *gitdir: //p' $(GIT_DIRECTORY))
ifneq ($(ALTERNATIVE_GIT),)
GIT_DIRECTORY:=$(ALTERNATIVE_GIT)
endif

# Get the current hash
CURRENT_HASH:=$(shell git log -1 --pretty=%h)
CURRENT_HASH_LONG:=$(shell git log -1 --pretty=%H)

# Get the pull request number, if this is a pull request
# Jenkins may set either CHANGE_ID or ghprbPullId
# Azure Devops sets SYSTEM_PULLREQUEST_PULLREQUESTNUMBER
ifneq ($(CHANGE_ID),)
PULL_REQUEST_ID=$(CHANGE_ID)
else ifneq ($(ghprbPullId),)
PULL_REQUEST_ID=$(ghprbPullId)
else ifneq ($(SYSTEM_PULLREQUEST_PULLREQUESTNUMBER),)
PULL_REQUEST_ID=$(SYSTEM_PULLREQUEST_PULLREQUESTNUMBER)
endif

# We have three types of branches:
#
# 1. Release (stable) branches. These have stable versioning (no prerelease identifiers).
# 2. Pre-release branches. These have stable versioning + prerelease identifiers.
# 3. Any other branches, These have CI/PR versioning.
#
# * A PR branch (case 3 above) is identified by the PULL_REQUEST_ID variable
#   (set in the environment). This takes precedence over any other variable.
# * Otherwise a release branch (case 1 above) is identified by setting the
#   NUGET_RELEASE_BRANCH variable to the name of the release branch (this
#   seems redundant: why should a branch name itself? but it's important if
#   another branch is created from the release branch: that other branch might
#   be any other random branch for whatever purpose, and shouldn't be
#   considered a release branch just because someone forgot to unset a
#   variable).
# * Otherwise a prerelease branch (case 2 above) is identified by the
#   NUGET_HARDCODED_PRERELEASE_IDENTIFIER variable, which is used to hardcode
#   a prerelease version. Note that NUGET_HARDCODED_PRERELEASE_BRANCH must
#   also be set to the name of the current branch, otherwise
#   NUGET_HARDCODED_PRERELEASE_IDENTIFIER will be ignored.
# * Otherwise we're a CI branch (case 3 above).

## If this branch is a release branch, set NUGET_RELEASE_BRANCH to the exact branch name (so that any other branches won't become release branches just by branching off from a release branch).
## Example: release/6.0.3xx
NUGET_RELEASE_BRANCH=release/11.0.1xx

## If this is a pre-release (alpha, beta, rc, xcode, etc.) branch, set NUGET_HARDCODED_PRERELASE_BRANCH to the exact branch name. Also set NUGET_HARDCODED_PRELEASE_IDENTIFIER to the prerelease identifier to use.
## Example:
##   NUGET_HARDCODED_PRERELEASE_BRANCH=release/6.0.3xx-rc3
##   NUGET_HARDCODED_PRERELEASE_IDENTIFIER=rc.3
## Example 2: we might sometimes make 'main' a prerelease branch:
##   NUGET_HARDCODED_PRERELEASE_BRANCH=main
##   NUGET_HARDCODED_PRERELEASE_IDENTIFIER=rc.4
## In this case, when we create an actual rc4 branch, the value for
## NUGET_HARDCODED_PRERELEASE_IDENTIFIER in main must be changed to "rc.5" (or
## anything else), while the value for NUGET_HARDCODED_PRERELEASE_BRANCH in
## the rc4 branch will become the rc4 branch name. The value in main must
## change *first*, otherwise we'll produce builds with the same version from
## two different branches (which is very, very bad).
##
## Note that the prerelease identifier should be as short as possible, because otherwise
## the resulting package name can become too long for MSIs.
NUGET_HARDCODED_PRERELEASE_IDENTIFIER=net12-p1
NUGET_HARDCODED_PRERELEASE_BRANCH=main

# compute the alphanumeric version of branch names
NUGET_RELEASE_BRANCH_ALPHANUMERIC:=$(shell export LANG=C; printf "%s" "$(NUGET_RELEASE_BRANCH)" | tr -c '[a-zA-Z0-9-]' '-')
NUGET_HARDCODED_PRERELEASE_BRANCH_ALPHANUMERIC:=$(shell export LANG=C; printf "%s" "$(NUGET_HARDCODED_PRERELEASE_BRANCH)" | tr -c '[a-zA-Z0-9-]' '-')

# Compute the prerelease identifier based on the variables above
# DO NOT MODIFY THE BELOW CONDITIONS TO HARDCODE A VERSION NUMBER FOR (PRE)RELEASE BRANCHES.
# READ INSTRUCTIONS ABOVE INSTEAD.
ifneq ($(PULL_REQUEST_ID),)
# we're a PR, so PR versioning
NUGET_PRERELEASE_IDENTIFIER=-ci.pr.gh$(PULL_REQUEST_ID)
else ifeq ($(NUGET_RELEASE_BRANCH_ALPHANUMERIC),$(CURRENT_BRANCH_ALPHANUMERIC))
# this is a release branch, so no prerelease identifier
NUGET_PRERELEASE_IDENTIFIER=
else ifeq ($(NUGET_HARDCODED_PRERELEASE_BRANCH_ALPHANUMERIC),$(CURRENT_BRANCH_ALPHANUMERIC))
# this is a prerelease branch!
NUGET_PRERELEASE_IDENTIFIER=-$(NUGET_HARDCODED_PRERELEASE_IDENTIFIER)
else ifeq (release-test/rt/,$(patsubst release-test/rt/%,release-test/rt/,$(CURRENT_BRANCH)))
# this is a release-testing branch!
NUGET_PRERELEASE_IDENTIFIER=-rt
else
# this is a CI branch!
NUGET_PRERELEASE_IDENTIFIER=-ci.$(CURRENT_BRANCH_ALPHANUMERIC)
endif

NUGET_BUILD_METADATA=

IOS_NUGET=Microsoft.iOS
IOS_NUGET_VERSION=$(IOS_NUGET_OS_VERSION).$(IOS_NUGET_COMMIT_DISTANCE)
IOS_NUGET_VERSION_MAJOR=$(word 1, $(subst ., ,$(IOS_NUGET_VERSION)))
IOS_NUGET_VERSION_MINOR=$(word 2, $(subst ., ,$(IOS_NUGET_VERSION)))
IOS_NUGET_VERSION_PATCH=$(word 3, $(subst ., ,$(IOS_NUGET_VERSION)))
IOS_NUGET_VERSION_NO_METADATA=$(IOS_NUGET_VERSION)$(NUGET_PRERELEASE_IDENTIFIER)
IOS_NUGET_VERSION_FULL=$(IOS_NUGET_VERSION_NO_METADATA)$(NUGET_BUILD_METADATA)

IOS_WINDOWS_NUGET=Microsoft.iOS.Windows
IOS_WINDOWS_NUGET_VERSION_MAJOR=$(IOS_NUGET_VERSION_MAJOR)
IOS_WINDOWS_NUGET_VERSION_MINOR=$(IOS_NUGET_VERSION_MINOR)
IOS_WINDOWS_NUGET_VERSION_PATCH=$(IOS_NUGET_VERSION_PATCH)
IOS_WINDOWS_NUGET_VERSION_NO_METADATA=$(IOS_NUGET_VERSION_NO_METADATA)
IOS_WINDOWS_NUGET_VERSION_FULL=$(IOS_NUGET_VERSION_FULL)

TVOS_NUGET=Microsoft.tvOS
TVOS_NUGET_VERSION=$(TVOS_NUGET_OS_VERSION).$(TVOS_NUGET_COMMIT_DISTANCE)
TVOS_NUGET_VERSION_MAJOR=$(word 1, $(subst ., ,$(TVOS_NUGET_VERSION)))
TVOS_NUGET_VERSION_MINOR=$(word 2, $(subst ., ,$(TVOS_NUGET_VERSION)))
TVOS_NUGET_VERSION_PATCH=$(word 3, $(subst ., ,$(TVOS_NUGET_VERSION)))
TVOS_NUGET_VERSION_NO_METADATA=$(TVOS_NUGET_VERSION)$(NUGET_PRERELEASE_IDENTIFIER)
TVOS_NUGET_VERSION_FULL=$(TVOS_NUGET_VERSION_NO_METADATA)$(NUGET_BUILD_METADATA)

MACCATALYST_NUGET=Microsoft.MacCatalyst
MACCATALYST_NUGET_VERSION=$(MACCATALYST_NUGET_OS_VERSION).$(MACCATALYST_NUGET_COMMIT_DISTANCE)
MACCATALYST_NUGET_VERSION_MAJOR=$(word 1, $(subst ., ,$(MACCATALYST_NUGET_VERSION)))
MACCATALYST_NUGET_VERSION_MINOR=$(word 2, $(subst ., ,$(MACCATALYST_NUGET_VERSION)))
MACCATALYST_NUGET_VERSION_PATCH=$(word 3, $(subst ., ,$(MACCATALYST_NUGET_VERSION)))
MACCATALYST_NUGET_VERSION_NO_METADATA=$(MACCATALYST_NUGET_VERSION)$(NUGET_PRERELEASE_IDENTIFIER)
MACCATALYST_NUGET_VERSION_FULL=$(MACCATALYST_NUGET_VERSION_NO_METADATA)$(NUGET_BUILD_METADATA)

-include $(TOP)/configure.inc

# Xcode version should have both a major and a minor version (even if the minor version is 0)
XCODE_VERSION=27.1
# CI provisions Xcode from an immutable Azure Artifacts Universal Package instead of
# Provisionator. The same feed and package names exist in every supported Azure DevOps
# organization; only the organization and project differ, and
# tools/devops/automation/scripts/bash/download-xcode-package.sh resolves those from the
# organization the build is running in:
#   DevDiv: https://devdiv.visualstudio.com/DevDiv/_artifacts/feed/macios-tools-internal/UPack/xcode-apple-silicon/
#   dnceng: https://dnceng.visualstudio.com/internal/_artifacts/feed/macios-tools-internal/UPack/xcode-apple-silicon/
# XCODE_URL is kept for local provisioning (./system-dependencies.sh --provision-xcode),
# which has no access to the internal feeds.
XCODE_PACKAGE_FEED=macios-tools-internal
XCODE_PACKAGE_NAME=xcode-apple-silicon
XCODE_PACKAGE_VERSION=27.1.0
XCODE_BUILD_VERSION=27A9275
XCODE_URL=https://bosstoragemirror.blob.core.windows.net/internal-files/xcodes/Xcode_27.1.xip
ifndef NO_XCODE
XCODE_DEVELOPER_ROOT?=/Applications/Xcode_27.1.0.app/Contents/Developer
ifneq (OK,$(shell test -d $(abspath $(XCODE_DEVELOPER_ROOT)) && echo OK))
NO_XCODE=1
$(warning The required Xcode ($(XCODE_VERSION)) is not installed in $(XCODE_DEVELOPER_ROOT) - this directory does not exist. Any parts of the build that require Xcode will be disabled.)
else
XCODE_PRODUCT_BUILD_VERSION:=$(shell /usr/libexec/PlistBuddy -c 'Print :ProductBuildVersion' $(XCODE_DEVELOPER_ROOT)/../version.plist 2>/dev/null)
ifeq (,$(XCODE_PRODUCT_BUILD_VERSION))
NO_XCODE=1
$(warning The required Xcode ($(XCODE_VERSION)) is not installed in $(XCODE_DEVELOPER_ROOT) - directory exists, but no version found. Any parts of the build that require Xcode will be disabled.)
endif
endif

# We define stable Xcode as the Xcode app being named like "Xcode_#.#[.#].app"
# and any other naming is deemed to be a beta. This is the safer approach: any
# errors are likely to be Xcode classified as a beta, when it's not, and in that
# case we'll accidentally release a prerelease version. This is not a problem:
# we fix it, and release the fixed version to stable. The opposite scenario is
# worse: when we release something as stable when it shouldn't be, so let's
# try to avoid that.
ifeq (OK,$(shell echo $(notdir $(abspath $(dir $(abspath $(dir $(XCODE_DEVELOPER_ROOT)))))) | sed -e 's/^Xcode[_0-9.]*[.]app$$/OK/'))
XCODE_IS_STABLE=true
XCODE_IS_PREVIEW=false
else
XCODE_IS_STABLE=false
XCODE_IS_PREVIEW=true
endif

# Tell both Xcode and our build logic which Xcode we're using.
export DEVELOPER_DIR=$(XCODE_DEVELOPER_ROOT)
else
# Without Xcode, set placeholder Xcode values but honor XCODE_CHANNEL so we configure bots correctly
ifeq ($(XCODE_CHANNEL),Beta)
XCODE_IS_STABLE=false
XCODE_IS_PREVIEW=true
else
XCODE_IS_STABLE=true
XCODE_IS_PREVIEW=false
endif
endif

# We don't need to be told there are workload updates
export DOTNET_CLI_WORKLOAD_UPDATE_NOTIFY_DISABLE=true
# No telemetry for us
export DOTNET_CLI_TELEMETRY_OPTOUT=1
# We don't need to be told we're using preview packages (we pretty much always are).
export SuppressNETCoreSdkPreviewMessage=true

# The Arcade SDK imported by the Xamarin.MacDev submodule overrides
# NuGetPackageRoot in CI, breaking the netstandard2.0 build.
# Pass the correct path explicitly.
export NuGetPackageRoot=$(abspath $(TOP)/packages)/

# The expected macOS build version for running tests.
# To get the build version for the current macOS, run: sysctl -n kern.osversion
# If the running macOS build version doesn't match, macOS/Mac Catalyst tests will be skipped.
# Set to empty to disable the check (this is what we do on stable branches).
EXPECTED_MACOS_BUILD_VERSION=26A428

# Minimum OSX versions for building XI/XM
MIN_OSX_BUILD_VERSION=15.3

# Bump the *_NUGET_VERSION variables in Make.versions instead, because that makes sure the computed commit distance for the version is correct.
IOS_SDK_VERSION=$(word 1, $(subst ., ,$(IOS_NUGET_VERSION))).$(word 2, $(subst ., ,$(IOS_NUGET_VERSION)))
MACOS_SDK_VERSION=$(word 1, $(subst ., ,$(MACOS_NUGET_VERSION))).$(word 2, $(subst ., ,$(MACOS_NUGET_VERSION)))
TVOS_SDK_VERSION=$(word 1, $(subst ., ,$(TVOS_NUGET_VERSION))).$(word 2, $(subst ., ,$(TVOS_NUGET_VERSION)))
MACCATALYST_SDK_VERSION=$(word 1, $(subst ., ,$(MACCATALYST_NUGET_VERSION))).$(word 2, $(subst ., ,$(MACCATALYST_NUGET_VERSION)))

MAX_IOS_DEPLOYMENT_TARGET=$(IOS_SDK_VERSION)
MAX_TVOS_DEPLOYMENT_TARGET=$(TVOS_SDK_VERSION)

# Decide which OS version we should run the simulator tests in.
# Note that this may not necessarily match the SDK version, if there are OS releases with no API changes, then there wouldn't necessarily be a corresponding SDK version.
# If the errors below trigger, update the hardcoded Xcode version check (currently 26.6) to use the current Xcode version, and assign the corresponding max simulator versions.
ifeq ($(XCODE_VERSION),27.1)
MAX_IOS_SIMULATOR_VERSION=27.1
MAX_TVOS_SIMULATOR_VERSION=27.0
else ifneq ($(XCODE_VERSION),$(IOS_SDK_VERSION))
$(error Check if a max iOS simulator is different than the current SDK version (this happens when there's a new iOS release, with no API changes so no new SDK))
else ifneq ($(XCODE_VERSION),$(TVOS_SDK_VERSION))
$(error Check if a max tvOS simulator is different than the current SDK version (this happens when there's a new tvOS release, with no API changes so no new SDK))
else
MAX_IOS_SIMULATOR_VERSION=$(IOS_SDK_VERSION)
MAX_TVOS_SIMULATOR_VERSION=$(TVOS_SDK_VERSION)
endif

# Minimum OS versions for .NET support
DOTNET_MIN_IOS_SDK_VERSION=15.0
DOTNET_MIN_TVOS_SDK_VERSION=15.0
DOTNET_MIN_MACCATALYST_SDK_VERSION=17.0
DOTNET_MIN_MACOS_SDK_VERSION=14.0

# The min simulator version available in the Xcode we're using
MIN_IOS_SIMULATOR_VERSION=17.0
MIN_TVOS_SIMULATOR_VERSION=17.0
# These are the simulator package ids for the versions above
EXTRA_SIMULATORS=iOS:MIN_IOS_SIMULATOR_VERSION tvOS:MIN_TVOS_SIMULATOR_VERSION

ifeq ($(ONLY_SHARPIE),)
ifneq ($(filter $(CURRENT_BRANCH),release/sharpie release-test/only-sharpie),)
ONLY_SHARPIE=1
endif
endif

ifndef ONLY_SHARPIE
INCLUDE_IOS=1
INCLUDE_MAC=1
INCLUDE_TVOS=1
INCLUDE_MACCATALYST=1
endif

INCLUDE_SIMULATOR=1
INCLUDE_DEVICE=1

-include $(TOP)/Make.config.local
-include $(TOP)/configure.inc

# misc Xcode tool
CLANG=$(CCACHE)$(XCODE_DEVELOPER_ROOT)/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
SWIFTC=$(XCODE_DEVELOPER_ROOT)/Toolchains/XcodeDefault.xctoolchain/usr/bin/swiftc
LIPO=$(XCODE_DEVELOPER_ROOT)/Toolchains/XcodeDefault.xctoolchain/usr/bin/lipo
AR=$(XCODE_DEVELOPER_ROOT)/Toolchains/XcodeDefault.xctoolchain/usr/bin/ar
RANLIB=$(XCODE_DEVELOPER_ROOT)/Toolchains/XcodeDefault.xctoolchain/usr/bin/ranlib

# paths to the modules we depend on, as variables, so people can put
# things in other places if they absolutely must.
XAMARIN_MACDEV_PATH=$(TOP)/external/Xamarin.MacDev

MACOS_NUGET=Microsoft.macOS
MACOS_NUGET_VERSION=$(MACOS_NUGET_OS_VERSION).$(MACOS_NUGET_COMMIT_DISTANCE)
MACOS_NUGET_VERSION_MAJOR=$(word 1, $(subst ., ,$(MACOS_NUGET_VERSION)))
MACOS_NUGET_VERSION_MINOR=$(word 2, $(subst ., ,$(MACOS_NUGET_VERSION)))
MACOS_NUGET_VERSION_PATCH=$(word 3, $(subst ., ,$(MACOS_NUGET_VERSION)))
MACOS_NUGET_VERSION_NO_METADATA=$(MACOS_NUGET_VERSION)$(NUGET_PRERELEASE_IDENTIFIER)
MACOS_NUGET_VERSION_FULL=$(MACOS_NUGET_VERSION_NO_METADATA)$(NUGET_BUILD_METADATA)

TT = $(DOTNET) tool restore && $(DOTNET) t4

PRODUCT_KEY_PATH?=$(TOP)/product.snk

include $(TOP)/mk/quiet.mk

JENKINS_RESULTS_DIRECTORY ?= $(abspath $(TOP)/jenkins-results)

# Clone files instead of copying them on APFS file systems. Much faster.
CP:=$(shell df -t apfs / >/dev/null 2>&1 && echo "cp -c" || echo "cp")

# This variable includes all the platforms we support, even those that might be disabled in this build.
ALL_DOTNET_PLATFORMS=iOS macOS tvOS MacCatalyst

# Set this to 1 if the Microsoft.NETCore.App.Ref dependency in eng/Version.Details.xml does *not* specify a CoherentParentDependency on Microsoft.Dotnet.Sdk.Internal.
TRACKING_DOTNET_RUNTIME_SEPARATELY=

# If you build dotnet/runtime locally, "*-dev" is the version the built artifacts will use (and which we must reference)
CUSTOM_DOTNET_VERSION:=$(subst net,,$(DOTNET_TFM)).0-dev

-include $(TOP)/dotnet.config
$(TOP)/dotnet.config: $(TOP)/eng/Version.Details.props $(TOP)/Build.props
	$(Q) rm -f $@.tmp
	$(Q) grep '<MicrosoftNETSdkPackageVersion>' $(TOP)/eng/Version.Details.props | sed -e 's/<*\/*MicrosoftNETSdkPackageVersion>//g' -e 's/[ \t]*/DOTNET_VERSION=/' >> $@.tmp
ifdef CUSTOM_DOTNET
	$(Q) echo "BUNDLED_NETCORE_PLATFORMS_PACKAGE_VERSION=$(CUSTOM_DOTNET_VERSION)" >> $@.tmp
else
	$(Q) grep '<MicrosoftNETCoreAppRefPackageVersion>' $(TOP)/eng/Version.Details.props | sed -e 's/<*\/*MicrosoftNETCoreAppRefPackageVersion>//g' -e 's/[ \t]*/BUNDLED_NETCORE_PLATFORMS_PACKAGE_VERSION=/' >> $@.tmp
endif
	$(Q) $(foreach platform,$(ALL_DOTNET_PLATFORMS),grep '<Microsoft$(platform)SdkPackageVersion>' $(TOP)/eng/Version.Details.props | sed -e 's/<*\/*Microsoft$(platform)SdkPackageVersion>//g' -e 's/[ \t]*/NET8_$(call uppercase,$(platform))_NUGET_VERSION_NO_METADATA=/' >> $@.tmp &&) true
	$(Q) grep '<MicrosoftDotNetArcadeSdkPackageVersion>' $(TOP)/eng/Version.Details.props | sed -e 's/<*\/*MicrosoftDotNetArcadeSdkPackageVersion>//g' -e 's/[ \t]*/ARCADE_VERSION=/' >> $@.tmp
	$(Q) mv $@.tmp $@

# Also depend on configure.inc, because it can change which Xcode we're using (and thus whether
# we're using a stable or a beta Xcode). Otherwise an early 'make' (such as the one that generates
# the provisionator files) might generate this file using whatever Xcode happens to be selected
# before the right Xcode is configured, and it wouldn't be regenerated afterwards.
$(TOP)/Build.props: $(TOP)/Make.config $(wildcard $(TOP)/configure.inc)
	$(Q) rm -f $@.tmp
	$(Q) printf "<Project>\n" >> $@.tmp
	$(Q) printf "\t<PropertyGroup>\n" >> $@.tmp
ifeq ($(XCODE_IS_STABLE),true)
	# do nothing
else ifeq ($(XCODE_IS_STABLE),false)
	$(Q) printf '\t\t<NoWarn>$$(NoWarn);XCODE_$(subst .,_,$(XCODE_VERSION))_PREVIEW</NoWarn>\n' >> $@.tmp
else
	$(error "The variable XCODE_IS_STABLE is not set!")
endif
	$(Q) printf "\t\t<TRACKING_DOTNET_RUNTIME_SEPARATELY>$(TRACKING_DOTNET_RUNTIME_SEPARATELY)</TRACKING_DOTNET_RUNTIME_SEPARATELY>\n" >> $@.tmp
	$(Q) printf "\t\t<CURRENT_BRANCH>$(CURRENT_BRANCH)</CURRENT_BRANCH>\n" >> $@.tmp
	$(Q) printf "\t\t<CURRENT_HASH_LONG>$(CURRENT_HASH_LONG)</CURRENT_HASH_LONG>\n" >> $@.tmp
	$(Q) printf "\t</PropertyGroup>\n" >> $@.tmp
	$(Q) printf "</Project>\n" >> $@.tmp
	$(Q) mv $@.tmp $@

DOTNET_DESTDIR ?= $(TOP)/_build
DOTNET_NUPKG_DIR ?= $(DOTNET_DESTDIR)/nupkgs
DOTNET_PKG_DIR ?= $(DOTNET_DESTDIR)/pkgs

ifdef CUSTOM_DOTNET
DOTNET_BCL_VERSION=$(CUSTOM_DOTNET_VERSION)
export CUSTOM_DOTNET_VERSION
else
DOTNET_BCL_VERSION=$(BUNDLED_NETCORE_PLATFORMS_PACKAGE_VERSION)
endif


DOTNET_VERSION_BAND=$(firstword $(subst -, ,$(DOTNET_VERSION)))
DOTNET_VERSION_PRERELEASE_COMPONENT=$(subst $(DOTNET_VERSION_BAND),,$(DOTNET_VERSION))
DOTNET_INSTALL_NAME=dotnet-sdk-$(DOTNET_VERSION)
DOTNET_DIR=$(abspath $(TOP)/builds/downloads/$(DOTNET_INSTALL_NAME))
# DOTNET_ROOT is no longer considered to find dotnet as seen here dotnet/roslyn@f454d69
# but it seems that some tools like csc still needs it so let's export it.
export DOTNET_ROOT=$(DOTNET_DIR)
# dotnet now is being looked up in the PATH
export PATH := $(DOTNET_DIR):$(PATH)

# Disable build servers to prevent parallel make from hanging.
# Build servers (MSBuild server, Roslyn/VBCSCompiler) inherit jobserver file
# descriptors from make, and don't close them when daemonizing. This prevents
# make from detecting that all jobs have finished, causing it to hang
# indefinitely at the end of the build.
export DOTNET_CLI_USE_MSBUILD_SERVER=0
export UseSharedCompilation=false
export MSBUILDDISABLENODEREUSE=1
DOTNET=$(DOTNET_DIR)/dotnet
DOTNET_BCL_DIR:=$(abspath $(TOP)/packages/microsoft.netcore.app.ref/$(DOTNET_BCL_VERSION)/ref/$(DOTNET_TFM))
# when bumping to a new .NET version, there may be a period when some parts of .NET is still on the old .NET version, so handle that here for DOTNET_BCL_DIR
ifneq ($(DOTNET_BCL_DIR),$(shell ls -1d $(DOTNET_BCL_DIR) 2>/dev/null))
DOTNET_BCL_DIR:=$(abspath $(wildcard $(TOP)/packages/microsoft.netcore.app.ref/$(DOTNET_BCL_VERSION)/ref/net*.0))
endif
DOTNET_ANALYZERS_DIR?=$(DOTNET_DIR)/sdk/$(DOTNET_VERSION_BAND)/Sdks/Microsoft.NET.Sdk/analyzers

# The sdk version band has the last two digits set to 0: https://github.com/dotnet/sdk/blob/22c4860dcb2cf6b123dd641cc4a87a50380759d5/src/Resolvers/Microsoft.NET.Sdk.WorkloadManifestReader/SdkDirectoryWorkloadManifestProvider.cs#L52-L53
# Simply-expanded (:=) so the subprocess runs once instead of on every reference (this variable's value never changes).
DOTNET_MANIFEST_VERSION_BAND:=$(shell echo $(DOTNET_VERSION_BAND) | sed 's/..$$/00/')
ifeq ($(DOTNET_VERSION_PRERELEASE_COMPONENT),)
DOTNET_MANIFEST_VERSION_BAND_WITH_PRERELEASE_COMPONENT=$(DOTNET_MANIFEST_VERSION_BAND)
else ifeq ($(word 1,$(subst ., ,$(DOTNET_VERSION_PRERELEASE_COMPONENT))),-rtm)
DOTNET_MANIFEST_VERSION_BAND_WITH_PRERELEASE_COMPONENT=$(DOTNET_MANIFEST_VERSION_BAND)
else ifeq ($(word 1,$(subst ., ,$(DOTNET_VERSION_PRERELEASE_COMPONENT))),-servicing)
DOTNET_MANIFEST_VERSION_BAND_WITH_PRERELEASE_COMPONENT=$(DOTNET_MANIFEST_VERSION_BAND)
else
DOTNET_MANIFEST_VERSION_BAND_WITH_PRERELEASE_COMPONENT=$(DOTNET_MANIFEST_VERSION_BAND)$(word 1,$(subst ., ,$(DOTNET_VERSION_PRERELEASE_COMPONENT))).$(word 2,$(subst ., ,$(DOTNET_VERSION_PRERELEASE_COMPONENT)))
endif

# This is the manifest version band we use for our .Manifest-$(VERSION_BAND) packages.
# It should typically be $(DOTNET_MANIFEST_VERSION_BAND_WITH_PRERELEASE_COMPONENT), unless we decide to hardcode it to something else
MACIOS_MANIFEST_VERSION_BAND=$(DOTNET_MANIFEST_VERSION_BAND_WITH_PRERELEASE_COMPONENT)

# The location of csc changes depending on whether we're using a preview or a stable/service release :/
DOTNET_CSC_PATH_PREVIEW=$(DOTNET_DIR)/sdk/$(DOTNET_VERSION)/Roslyn/bincore/csc.dll
DOTNET_CSC_PATH_STABLE=$(DOTNET_DIR)/sdk/$(DOTNET_VERSION_BAND)/Roslyn/bincore/csc.dll

# Attempt to detect where csc is based. This may fail in the future: feel free to fix/hardcode whatever's necessary to find csc.dll.
ifneq ("$(wildcard $(DOTNET_CSC_PATH_STABLE))","")
DOTNET_CSC=$(DOTNET) exec $(DOTNET_CSC_PATH_STABLE)
else
DOTNET_CSC=$(DOTNET) exec $(DOTNET_CSC_PATH_PREVIEW)
endif

# How are our assemblies named?
DOTNET_IOS_ASSEMBLY_NAME=Microsoft.iOS
DOTNET_TVOS_ASSEMBLY_NAME=Microsoft.tvOS
DOTNET_MACCATALYST_ASSEMBLY_NAME=Microsoft.MacCatalyst
DOTNET_MACOS_ASSEMBLY_NAME=Microsoft.macOS

DOTNET_PLATFORMS=

ifdef INCLUDE_IOS
DOTNET_PLATFORMS+=iOS
DOTNET_CORECLR_PLATFORMS+=iOS
DOTNET_NATIVEAOT_PLATFORMS+=iOS
DOTNET_IOS_RUNTIME_IDENTIFIERS_NO_ARCH=ios

ifdef INCLUDE_SIMULATOR
DOTNET_IOS_RUNTIME_IDENTIFIERS_SIMULATOR+=iossimulator-arm64
XCFRAMEWORK_iOS_PLATFORMS+=iossimulator
XCFRAMEWORK_iossimulator_RUNTIME_IDENTIFIERS+=$(DOTNET_IOS_RUNTIME_IDENTIFIERS_SIMULATOR)
DOTNET_IOS_RUNTIME_IDENTIFIERS+=$(DOTNET_IOS_RUNTIME_IDENTIFIERS_SIMULATOR)
DOTNET_iOS_SDK_PLATFORMS+=iphonesimulator
endif # INCLUDE_SIMULATOR

ifdef INCLUDE_DEVICE
DOTNET_IOS_RUNTIME_IDENTIFIERS_DEVICE+=ios-arm64
XCFRAMEWORK_iOS_PLATFORMS+=ios
XCFRAMEWORK_ios_RUNTIME_IDENTIFIERS+=$(DOTNET_IOS_RUNTIME_IDENTIFIERS_DEVICE)
DOTNET_IOS_RUNTIME_IDENTIFIERS+=$(DOTNET_IOS_RUNTIME_IDENTIFIERS_DEVICE)
DOTNET_iOS_SDK_PLATFORMS+=iphoneos
endif # INCLUDE_DEVICE

XCFRAMEWORK_PLATFORMS+=$(XCFRAMEWORK_iOS_PLATFORMS)
endif # INCLUDE_IOS

ifdef INCLUDE_TVOS
DOTNET_PLATFORMS+=tvOS
DOTNET_CORECLR_PLATFORMS+=tvOS
DOTNET_NATIVEAOT_PLATFORMS+=tvOS
DOTNET_TVOS_RUNTIME_IDENTIFIERS_NO_ARCH=tvos

ifdef INCLUDE_SIMULATOR
DOTNET_TVOS_RUNTIME_IDENTIFIERS_SIMULATOR+=tvossimulator-arm64
XCFRAMEWORK_tvOS_PLATFORMS+=tvossimulator
XCFRAMEWORK_tvossimulator_RUNTIME_IDENTIFIERS=$(DOTNET_TVOS_RUNTIME_IDENTIFIERS_SIMULATOR)
DOTNET_TVOS_RUNTIME_IDENTIFIERS+=$(DOTNET_TVOS_RUNTIME_IDENTIFIERS_SIMULATOR)
DOTNET_tvOS_SDK_PLATFORMS+=tvsimulator
endif # INCLUDE_SIMULATOR

ifdef INCLUDE_DEVICE
DOTNET_TVOS_RUNTIME_IDENTIFIERS_DEVICE+=tvos-arm64
XCFRAMEWORK_tvOS_PLATFORMS+=tvos
XCFRAMEWORK_tvos_RUNTIME_IDENTIFIERS=$(DOTNET_TVOS_RUNTIME_IDENTIFIERS_DEVICE)
DOTNET_TVOS_RUNTIME_IDENTIFIERS+=$(DOTNET_TVOS_RUNTIME_IDENTIFIERS_DEVICE)
DOTNET_tvOS_SDK_PLATFORMS+=tvos
endif

XCFRAMEWORK_PLATFORMS+=$(XCFRAMEWORK_tvOS_PLATFORMS)
endif

ifdef INCLUDE_MACCATALYST
DOTNET_PLATFORMS+=MacCatalyst
DOTNET_CORECLR_PLATFORMS+=MacCatalyst
DOTNET_NATIVEAOT_PLATFORMS+=MacCatalyst
DOTNET_MACCATALYST_RUNTIME_IDENTIFIERS_NO_ARCH=maccatalyst
DOTNET_MACCATALYST_RUNTIME_IDENTIFIERS=maccatalyst-x64 maccatalyst-arm64
DOTNET_MacCatalyst_SDK_PLATFORMS+=maccatalyst
XCFRAMEWORK_PLATFORMS+=maccatalyst
XCFRAMEWORK_MacCatalyst_PLATFORMS+=maccatalyst
XCFRAMEWORK_DESKTOP_PLATFORMS+=maccatalyst
XCFRAMEWORK_maccatalyst_RUNTIME_IDENTIFIERS=$(DOTNET_MACCATALYST_RUNTIME_IDENTIFIERS)
endif

ifdef INCLUDE_MAC
DOTNET_PLATFORMS+=macOS
DOTNET_CORECLR_PLATFORMS+=macOS
DOTNET_NATIVEAOT_PLATFORMS+=macOS
DOTNET_MACOS_RUNTIME_IDENTIFIERS_NO_ARCH=osx
DOTNET_MACOS_RUNTIME_IDENTIFIERS=osx-x64 osx-arm64
DOTNET_macOS_SDK_PLATFORMS+=mac
XCFRAMEWORK_PLATFORMS+=macos
XCFRAMEWORK_macOS_PLATFORMS+=macos
XCFRAMEWORK_DESKTOP_PLATFORMS+=macos
XCFRAMEWORK_macos_RUNTIME_IDENTIFIERS=$(DOTNET_MACOS_RUNTIME_IDENTIFIERS)
endif

ifdef INCLUDE_IOS
DOTNET_WINDOWS_PLATFORMS = iOS
endif

# Uppercase/lowercase a string using only make built-ins (GNU make has no toupper/tolower function). This avoids spawning a subprocess (echo | tr) for every conversion, which noticeably slows down makefile parsing.
uppercase = $(subst a,A,$(subst b,B,$(subst c,C,$(subst d,D,$(subst e,E,$(subst f,F,$(subst g,G,$(subst h,H,$(subst i,I,$(subst j,J,$(subst k,K,$(subst l,L,$(subst m,M,$(subst n,N,$(subst o,O,$(subst p,P,$(subst q,Q,$(subst r,R,$(subst s,S,$(subst t,T,$(subst u,U,$(subst v,V,$(subst w,W,$(subst x,X,$(subst y,Y,$(subst z,Z,$(1)))))))))))))))))))))))))))
lowercase = $(subst A,a,$(subst B,b,$(subst C,c,$(subst D,d,$(subst E,e,$(subst F,f,$(subst G,g,$(subst H,h,$(subst I,i,$(subst J,j,$(subst K,k,$(subst L,l,$(subst M,m,$(subst N,n,$(subst O,o,$(subst P,p,$(subst Q,q,$(subst R,r,$(subst S,s,$(subst T,t,$(subst U,u,$(subst V,v,$(subst W,w,$(subst X,x,$(subst Y,y,$(subst Z,z,$(1)))))))))))))))))))))))))))

# The platform names in all uppercase / all lowercase. These simplify code that foreaches over the platforms and only needs the upper/lower-cased name.
DOTNET_PLATFORMS_UPPERCASE:=$(strip $(call uppercase,$(DOTNET_PLATFORMS)))
DOTNET_PLATFORMS_LOWERCASE:=$(strip $(call lowercase,$(DOTNET_PLATFORMS)))

# Create variables prefixed with the correctly cased platform name from the upper-cased platform name. This simplifies code in a few areas (whenever we foreach over DOTNET_PLATFORMS).
$(foreach platform,$(DOTNET_PLATFORMS),$(eval DOTNET_$(platform)_RUNTIME_IDENTIFIERS_NO_ARCH:=$(DOTNET_$(call uppercase,$(platform))_RUNTIME_IDENTIFIERS_NO_ARCH)))
$(foreach platform,$(DOTNET_PLATFORMS),$(eval DOTNET_$(platform)_RUNTIME_IDENTIFIERS:=$(DOTNET_$(call uppercase,$(platform))_RUNTIME_IDENTIFIERS)))
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(platform)_NUGET_OS_VERSION:=$($(call uppercase,$(platform))_NUGET_OS_VERSION)))

# Create a variable with all the runtime identifiers
DOTNET_RUNTIME_IDENTIFIERS=$(foreach platform,$(DOTNET_PLATFORMS),$(DOTNET_$(platform)_RUNTIME_IDENTIFIERS))

# Create a variable with all the CoreCLR runtime identifiers
DOTNET_CORECLR_RUNTIME_IDENTIFIERS=$(foreach platform,$(DOTNET_CORECLR_PLATFORMS),$(DOTNET_$(platform)_RUNTIME_IDENTIFIERS))

# All desktop platforms we're building for
DOTNET_DESKTOP_PLATFORMS:=$(filter macOS MacCatalyst,$(DOTNET_PLATFORMS))

# a few lookup tables, because the data we have is not always in the format we need it

# RUNTIMEIDENTIFIER -> architecture
DOTNET_iossimulator-arm64_ARCHITECTURES=arm64
DOTNET_iossimulator-x86_ARCHITECTURES=x86
DOTNET_ios-arm64_ARCHITECTURES=arm64
DOTNET_tvossimulator-arm64_ARCHITECTURES=arm64
DOTNET_tvos-arm64_ARCHITECTURES=arm64
DOTNET_osx-x64_ARCHITECTURES=x86_64
DOTNET_osx-arm64_ARCHITECTURES=arm64
DOTNET_maccatalyst-x64_ARCHITECTURES=x86_64
DOTNET_maccatalyst-arm64_ARCHITECTURES=arm64

DOTNET_iossimulator-arm64_SDK_PLATFORM=iphonesimulator
DOTNET_iossimulator-x86_SDK_PLATFORM=iphonesimulator
DOTNET_ios-arm_SDK_PLATFORM=iphoneos
DOTNET_ios-arm64_SDK_PLATFORM=iphoneos
DOTNET_tvossimulator-arm64_SDK_PLATFORM=tvsimulator
DOTNET_tvos-arm64_SDK_PLATFORM=tvos
DOTNET_osx-x64_SDK_PLATFORM=mac
DOTNET_osx-arm64_SDK_PLATFORM=mac
DOTNET_maccatalyst-x64_SDK_PLATFORM=maccatalyst
DOTNET_maccatalyst-arm64_SDK_PLATFORM=maccatalyst

# XCFRAMEWORK_PLATFORM -> PLATFORM
DOTNET_iossimulator_PLATFORM=ios
DOTNET_ios_PLATFORM=ios
DOTNET_tvossimulator_PLATFORM=tvos
DOTNET_tvos_PLATFORM=tvos
DOTNET_maccatalyst_PLATFORM=maccatalyst
DOTNET_macos_PLATFORM=macos

# XCFRAMEWORK -> clang argument for min OS version
CLANG_iossimulator-arm64_VERSION_MIN=-mios-simulator-version-min=$(DOTNET_MIN_IOS_SDK_VERSION)
CLANG_ios-arm64_VERSION_MIN=-miphoneos-version-min=$(DOTNET_MIN_IOS_SDK_VERSION)
CLANG_tvossimulator-arm64_VERSION_MIN=-mtvos-simulator-version-min=$(DOTNET_MIN_TVOS_SDK_VERSION)
CLANG_tvos-arm64_VERSION_MIN=-mtvos-version-min=$(DOTNET_MIN_TVOS_SDK_VERSION)
CLANG_maccatalyst-x64_VERSION_MIN=-target x86_64-apple-ios$(DOTNET_MIN_MACCATALYST_SDK_VERSION)-macabi -arch x86_64
CLANG_maccatalyst-arm64_VERSION_MIN=-target arm64-apple-ios$(DOTNET_MIN_MACCATALYST_SDK_VERSION)-macabi -arch arm64
CLANG_osx-x64_VERSION_MIN=-mmacosx-version-min=$(DOTNET_MIN_MACOS_SDK_VERSION)
CLANG_osx-arm64_VERSION_MIN=-mmacosx-version-min=$(DOTNET_MIN_MACOS_SDK_VERSION)

# RUNTIMEIDENTIFIER -> swiftc argument(s) for min OS version
SWIFTC_iossimulator-arm64_VERSION_MIN=-target arm64-apple-ios$(DOTNET_MIN_IOS_SDK_VERSION)-simulator
SWIFTC_ios-arm64_VERSION_MIN=-target arm64-apple-ios$(DOTNET_MIN_IOS_SDK_VERSION)
SWIFTC_tvossimulator-arm64_VERSION_MIN=-target arm64-apple-tvos$(DOTNET_MIN_TVOS_SDK_VERSION)-simulator
SWIFTC_tvos-arm64_VERSION_MIN=-target arm64-apple-tvos$(DOTNET_MIN_TVOS_SDK_VERSION)
SWIFTC_maccatalyst-x64_VERSION_MIN=-target x86_64-apple-ios$(DOTNET_MIN_MACCATALYST_SDK_VERSION)-macabi
SWIFTC_maccatalyst-arm64_VERSION_MIN=-target arm64-apple-ios$(DOTNET_MIN_MACCATALYST_SDK_VERSION)-macabi
SWIFTC_osx-x64_VERSION_MIN=-target x86_64-apple-macos$(DOTNET_MIN_MACOS_SDK_VERSION)
SWIFTC_osx-arm64_VERSION_MIN=-target arm64-apple-macos$(DOTNET_MIN_MACOS_SDK_VERSION)


# Misc other computed variables
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(call uppercase,$(platform))_NUGET_SDK_NAME=Microsoft.$(platform).Sdk.$(DOTNET_TFM)_$($(platform)_NUGET_OS_VERSION)))
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(call uppercase,$(platform))_NUGET_REF_NAME=Microsoft.$(platform).Ref.$(DOTNET_TFM)_$($(platform)_NUGET_OS_VERSION)))
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(call uppercase,$(platform))_NUGET_RUNTIME_MANAGED_NAME=Microsoft.$(platform).Runtime.$(DOTNET_$(call uppercase,$(platform))_RUNTIME_IDENTIFIERS_NO_ARCH).$(DOTNET_TFM)_$($(platform)_NUGET_OS_VERSION)))
$(foreach platform,$(DOTNET_PLATFORMS),$(foreach rid,$(DOTNET_$(call uppercase,$(platform))_RUNTIME_IDENTIFIERS),$(eval $(rid)_NUGET_RUNTIME_NAME=Microsoft.$(platform).Runtime.$(rid).$(DOTNET_TFM)_$($(platform)_NUGET_OS_VERSION))))
$(foreach platform,$(DOTNET_WINDOWS_PLATFORMS),$(eval $(call uppercase,$(platform))_NUGET_WINDOWS_SDK_NAME=Microsoft.$(platform).Windows.Sdk.$(DOTNET_TFM)_$($(platform)_NUGET_OS_VERSION)))

# Create variables prefixed with the correctly cased platform name from the upper-cased platform name. This simplifies code in a few areas (whenever we foreach over DOTNET_PLATFORMS).
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(platform)_NUGET_SDK_NAME:=$($(call uppercase,$(platform))_NUGET_SDK_NAME)))
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(platform)_NUGET_REF_NAME:=$($(call uppercase,$(platform))_NUGET_REF_NAME)))
$(foreach platform,$(DOTNET_PLATFORMS),$(eval $(platform)_NUGET_RUNTIME_MANAGED_NAME:=$($(call uppercase,$(platform))_NUGET_RUNTIME_MANAGED_NAME)))
$(foreach platform,$(DOTNET_WINDOWS_PLATFORMS),$(eval $(platform)_NUGET_WINDOWS_SDK_NAME:=$($(call uppercase,$(platform))_NUGET_WINDOWS_SDK_NAME)))

# A local feed to place test nugets.
NUGET_TEST_FEED=$(abspath $(TOP)/tests/.nuget/packages)

ifeq ($(shell arch),arm64)
ADR_RUNTIME_IDENTIFIER=osx-arm64
else ifeq ($(shell sysctl -n sysctl.proc_translated 2>/dev/null),1)
ADR_RUNTIME_IDENTIFIER=osx-arm64
else
ADR_RUNTIME_IDENTIFIER=osx-x64
endif

.SUFFIXES:
MAKEFLAGS += --no-builtin-rules