From 22412f73b70c3bfd70d6ae3f927a2319631f19f5 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Mon, 24 Aug 2026 15:36:20 +0100
Subject: [PATCH 01/27] ci(mirror_cspu): add dynamic branch mirroring via
 GitHub API

Co-authored-by: Bob <bob@ibm.com>
---
 Jenkinsfile    | 125 +++++++++++++++++++++++++++++++++++++++++++++++++
 skaraMirror.sh |  17 +++----
 2 files changed, 134 insertions(+), 8 deletions(-)
 create mode 100644 Jenkinsfile

diff --git a/Jenkinsfile b/Jenkinsfile
new file mode 100644
index 0000000..5095c47
--- /dev/null
+++ b/Jenkinsfile
@@ -0,0 +1,125 @@
+/*
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+pipeline {
+    agent { label 'worker' }
+
+    options {
+        buildDiscarder(logRotator(numToKeepStr: '30'))
+    }
+
+    triggers {
+        cron('H * * * *')
+    }
+
+    parameters {
+        string(
+            name: 'JDK_VERSION',
+            defaultValue: '',
+            description: 'The OpenJDK repository name to mirror from https://github.com/openjdk/ (e.g. jdk21u, jdk, jdk8u)'
+        )
+        string(
+            name: 'ADOPTIUM_MIRROR_REPO',
+            defaultValue: '',
+            description: '(Optional) Adoptium mirror GitHub repository name. Defaults to the JDK_VERSION value (e.g. adoptium/<JDK_VERSION>).'
+        )
+    }
+
+    stages {
+        stage('Validate Parameters') {
+            steps {
+                script {
+                    if (!params.JDK_VERSION?.trim()) {
+                        error('JDK_VERSION parameter is required.')
+                    }
+                }
+            }
+        }
+
+        stage('Determine Branches') {
+            steps {
+                script {
+                    def skaraRepo = "https://github.com/openjdk/${params.JDK_VERSION}"
+                    echo "Upstream SKARA_REPO: ${skaraRepo}"
+
+                    // Fetch the default branch name and all active branches via the GitHub API.
+                    // "Active" branches are those not marked as stale by GitHub (i.e. they appear
+                    // in the default branch listing without the --stale flag, equivalent to the
+                    // summary shown on the GitHub branches page).
+                    def apiBase = "https://api.github.com/repos/openjdk/${params.JDK_VERSION}"
+
+                    // Retrieve default branch
+                    def repoInfoJson = sh(
+                        script: "curl -fsSL '${apiBase}'",
+                        returnStdout: true
+                    ).trim()
+                    def repoInfo = readJSON text: repoInfoJson
+                    def defaultBranch = repoInfo.default_branch
+                    echo "Default branch: ${defaultBranch}"
+
+                    // Retrieve all active (non-stale) branches — paginate until exhausted
+                    def branches = [] as Set
+                    def page = 1
+                    while (true) {
+                        def pageJson = sh(
+                            script: "curl -fsSL '${apiBase}/branches?per_page=100&page=${page}'",
+                            returnStdout: true
+                        ).trim()
+                        def pageBranches = readJSON text: pageJson
+                        if (pageBranches.isEmpty()) {
+                            break
+                        }
+                        pageBranches.each { b -> branches.add(b.name) }
+                        page++
+                    }
+
+                    // Ensure the default branch is always included
+                    branches.add(defaultBranch)
+
+                    echo "Active branches to mirror: ${branches.join(', ')}"
+                    env.BRANCHES_TO_MIRROR = branches.join(' ')
+                    env.DEFAULT_BRANCH     = defaultBranch
+                }
+            }
+        }
+
+        stage('Mirror Branches') {
+            steps {
+                script {
+                    def mirrorRepoArg = params.ADOPTIUM_MIRROR_REPO?.trim() ?: ''
+                    def branchList = env.BRANCHES_TO_MIRROR.tokenize(' ')
+
+                    for (branch in branchList) {
+                        echo "--- Mirroring branch: ${branch} ---"
+                        withEnv(["BRANCH=${branch}"]) {
+                            sh """
+                                git --version
+                                bash ./skaraMirror.sh '${params.JDK_VERSION}' ${mirrorRepoArg ? "'${mirrorRepoArg}'" : ''}
+                            """
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    post {
+        failure {
+            echo 'Mirror job failed.'
+        }
+        success {
+            echo 'All branches mirrored successfully.'
+        }
+    }
+}
diff --git a/skaraMirror.sh b/skaraMirror.sh
index a53a975..2a50f31 100755
--- a/skaraMirror.sh
+++ b/skaraMirror.sh
@@ -267,17 +267,18 @@ checkArgs $#
 SKARA_REPO="https://github.com/openjdk/$1"
 GITHUB_REPO="$1"
 REPO=${2:-"git@github.com:adoptium/$GITHUB_REPO"}
-BRANCH=${BRANCH:=master}
 
-# Does this OpenJDK repo support version branching?
-VERSION_BRANCHING=false
-
-# jdk(head) is only repository currently supporting version branches
-if [[ "${GITHUB_REPO}" == "jdk" ]]; then
-  VERSION_BRANCHING=true
+# Determine the default branch of the upstream Skara repo
+SKARA_DEFAULT_BRANCH=$(curl -fsSL "https://api.github.com/repos/openjdk/${GITHUB_REPO}" | grep '"default_branch"' | head -1 | sed 's/.*"default_branch": *"\([^"]*\)".*/\1/' | tr -d '[:space:]')
+if [[ -z "${SKARA_DEFAULT_BRANCH}" ]]; then
+  echo "ERROR: Could not determine default branch for openjdk/${GITHUB_REPO} - GitHub API response was empty or unexpected"
+  exit 1
 fi
+echo "Upstream default branch: ${SKARA_DEFAULT_BRANCH}"
+
+BRANCH=${BRANCH:=${SKARA_DEFAULT_BRANCH}}
 
-if [[ "${VERSION_BRANCHING}" == false ]] || [[ "${BRANCH}" == "master" ]]; then
+if [[ "${BRANCH}" == "${SKARA_DEFAULT_BRANCH}" ]]; then
   RELEASE_BRANCH="release"
   DEV_BRANCH="dev"
 else

From b7ae7c7a72e5434e3caba05939ae355c50e73b7a Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Mon, 24 Aug 2026 16:18:56 +0100
Subject: [PATCH 02/27] ci(mirror_cspu): expand post-build handlers with all
 pipeline states

Co-authored-by: Bob <bob@ibm.com>
---
 Jenkinsfile | 25 +++++++++++++++++++++++--
 1 file changed, 23 insertions(+), 2 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 5095c47..8c4dfe8 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -115,11 +115,32 @@ pipeline {
     }
 
     post {
-        failure {
-            echo 'Mirror job failed.'
+        always {
+            echo 'Mirror job finished.'
         }
         success {
             echo 'All branches mirrored successfully.'
         }
+        unstable {
+            echo 'Mirror job completed with an unstable result.'
+        }
+        failure {
+            echo 'Mirror job failed.'
+        }
+        aborted {
+            echo 'Mirror job was aborted.'
+        }
+        changed {
+            echo 'Mirror job result has changed since the last run.'
+        }
+        fixed {
+            echo 'Mirror job is back to success after a previous failure.'
+        }
+        regression {
+            echo 'Mirror job was previously successful but is now failing.'
+        }
+        cleanup {
+            echo 'Mirror job post-processing complete.'
+        }
     }
 }

From b3b5b8eed6ae928c25d7fe2d365e379bbcc383e2 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Tue, 25 Aug 2026 09:43:23 +0100
Subject: [PATCH 03/27] ci(mirror_cspu): filter branches by 3-month staleness
 threshold via API

Co-authored-by: Bob <bob@ibm.com>
---
 Jenkinsfile | 34 +++++++++++++++++++++++++++++-----
 1 file changed, 29 insertions(+), 5 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 8c4dfe8..697a35d 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -54,9 +54,8 @@ pipeline {
                     echo "Upstream SKARA_REPO: ${skaraRepo}"
 
                     // Fetch the default branch name and all active branches via the GitHub API.
-                    // "Active" branches are those not marked as stale by GitHub (i.e. they appear
-                    // in the default branch listing without the --stale flag, equivalent to the
-                    // summary shown on the GitHub branches page).
+                    // "Active" branches match GitHub's own definition: last commit within 3 months,
+                    // which is the threshold used on the GitHub branches summary page.
                     def apiBase = "https://api.github.com/repos/openjdk/${params.JDK_VERSION}"
 
                     // Retrieve default branch
@@ -65,10 +64,18 @@ pipeline {
                         returnStdout: true
                     ).trim()
                     def repoInfo = readJSON text: repoInfoJson
+                    if (!repoInfo.default_branch) {
+                        error("GitHub API did not return a default_branch for openjdk/${params.JDK_VERSION} - response may be malformed")
+                    }
                     def defaultBranch = repoInfo.default_branch
                     echo "Default branch: ${defaultBranch}"
 
-                    // Retrieve all active (non-stale) branches — paginate until exhausted
+                    // Staleness threshold: 3 months ago (in milliseconds)
+                    def threeMonthsAgo = System.currentTimeMillis() - (90L * 24 * 60 * 60 * 1000)
+
+                    // Retrieve all branches and filter to active (non-stale) ones — paginate until exhausted.
+                    // For each branch we fetch the commit date via the /branches/<name> detail endpoint.
+                    // Use a for loop (not .each{}) so that any curl/parse failure propagates immediately.
                     def branches = [] as Set
                     def page = 1
                     while (true) {
@@ -80,7 +87,24 @@ pipeline {
                         if (pageBranches.isEmpty()) {
                             break
                         }
-                        pageBranches.each { b -> branches.add(b.name) }
+                        for (b in pageBranches) {
+                            def branchDetailJson = sh(
+                                script: "curl -fsSL '${apiBase}/branches/${b.name}'",
+                                returnStdout: true
+                            ).trim()
+                            def branchDetail = readJSON text: branchDetailJson
+                            if (!branchDetail?.commit?.commit?.committer?.date) {
+                                error("GitHub API did not return commit date for branch '${b.name}' - response may be malformed")
+                            }
+                            def commitDate = branchDetail.commit.commit.committer.date  // ISO-8601
+                            def commitMs = Date.parse("yyyy-MM-dd'T'HH:mm:ss'Z'", commitDate).getTime()
+                            if (commitMs >= threeMonthsAgo) {
+                                echo "Active branch: ${b.name} (last commit: ${commitDate})"
+                                branches.add(b.name)
+                            } else {
+                                echo "Stale branch (skipping): ${b.name} (last commit: ${commitDate})"
+                            }
+                        }
                         page++
                     }
 

From 238d7c2f02b98910998c005d51989a9536e6378e Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Tue, 25 Aug 2026 09:46:28 +0100
Subject: [PATCH 04/27] ci(mirror_cspu): remove static JDK_VERSION and
 ADOPTIUM_MIRROR_REPO parameters

Co-authored-by: Bob <bob@ibm.com>
---
 Jenkinsfile | 13 -------------
 1 file changed, 13 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 697a35d..a771d01 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -23,19 +23,6 @@ pipeline {
         cron('H * * * *')
     }
 
-    parameters {
-        string(
-            name: 'JDK_VERSION',
-            defaultValue: '',
-            description: 'The OpenJDK repository name to mirror from https://github.com/openjdk/ (e.g. jdk21u, jdk, jdk8u)'
-        )
-        string(
-            name: 'ADOPTIUM_MIRROR_REPO',
-            defaultValue: '',
-            description: '(Optional) Adoptium mirror GitHub repository name. Defaults to the JDK_VERSION value (e.g. adoptium/<JDK_VERSION>).'
-        )
-    }
-
     stages {
         stage('Validate Parameters') {
             steps {

From 490a4db1a31ad8de7c1c7d3cfc000c8bd32ab826 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Tue, 25 Aug 2026 09:47:34 +0100
Subject: [PATCH 05/27] fix(mirror_cspu): use java.time.Instant for ISO-8601
 date parsing

Co-authored-by: Bob <bob@ibm.com>
---
 Jenkinsfile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index a771d01..abd5e95 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -84,7 +84,7 @@ pipeline {
                                 error("GitHub API did not return commit date for branch '${b.name}' - response may be malformed")
                             }
                             def commitDate = branchDetail.commit.commit.committer.date  // ISO-8601
-                            def commitMs = Date.parse("yyyy-MM-dd'T'HH:mm:ss'Z'", commitDate).getTime()
+                            def commitMs = java.time.Instant.parse(commitDate).toEpochMilli()
                             if (commitMs >= threeMonthsAgo) {
                                 echo "Active branch: ${b.name} (last commit: ${commitDate})"
                                 branches.add(b.name)

From 5f8b66b08b87d7cc4aea15a307387c0e43bc7d12 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Tue, 25 Aug 2026 09:49:40 +0100
Subject: [PATCH 06/27] fix(mirror_cspu): replace epoch millis comparison with
 Instant for staleness check

Co-authored-by: Bob <bob@ibm.com>
---
 Jenkinsfile | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index abd5e95..ba4cfca 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -57,8 +57,8 @@ pipeline {
                     def defaultBranch = repoInfo.default_branch
                     echo "Default branch: ${defaultBranch}"
 
-                    // Staleness threshold: 3 months ago (in milliseconds)
-                    def threeMonthsAgo = System.currentTimeMillis() - (90L * 24 * 60 * 60 * 1000)
+                    // Staleness threshold: 3 months ago as an Instant
+                    def threeMonthsAgo = java.time.Instant.now().minus(90, java.time.temporal.ChronoUnit.DAYS)
 
                     // Retrieve all branches and filter to active (non-stale) ones — paginate until exhausted.
                     // For each branch we fetch the commit date via the /branches/<name> detail endpoint.
@@ -84,8 +84,8 @@ pipeline {
                                 error("GitHub API did not return commit date for branch '${b.name}' - response may be malformed")
                             }
                             def commitDate = branchDetail.commit.commit.committer.date  // ISO-8601
-                            def commitMs = java.time.Instant.parse(commitDate).toEpochMilli()
-                            if (commitMs >= threeMonthsAgo) {
+                            def commitInstant = java.time.Instant.parse(commitDate)
+                            if (!commitInstant.isBefore(threeMonthsAgo)) {
                                 echo "Active branch: ${b.name} (last commit: ${commitDate})"
                                 branches.add(b.name)
                             } else {

From 16581ca365ace958f4183de392f1ab5c909c7bd3 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Tue, 25 Aug 2026 09:52:42 +0100
Subject: [PATCH 07/27] fix(mirror_cspu): replace java.time.Instant with shell
 date for sandbox-safe staleness check

Co-authored-by: Bob <bob@ibm.com>
---
 Jenkinsfile | 22 ++++++++++++++++++----
 1 file changed, 18 insertions(+), 4 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index ba4cfca..f07ccde 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -57,8 +57,15 @@ pipeline {
                     def defaultBranch = repoInfo.default_branch
                     echo "Default branch: ${defaultBranch}"
 
-                    // Staleness threshold: 3 months ago as an Instant
-                    def threeMonthsAgo = java.time.Instant.now().minus(90, java.time.temporal.ChronoUnit.DAYS)
+                    // Staleness threshold: unix timestamp 90 days ago, computed via shell (sandbox-safe)
+                    def threeMonthsAgoStr = sh(
+                        script: "date -d '90 days ago' +%s",
+                        returnStdout: true
+                    ).trim()
+                    if (!threeMonthsAgoStr.isLong()) {
+                        error("Failed to compute staleness threshold: 'date -d 90 days ago' returned unexpected output: '${threeMonthsAgoStr}'")
+                    }
+                    def threeMonthsAgoEpoch = threeMonthsAgoStr as long
 
                     // Retrieve all branches and filter to active (non-stale) ones — paginate until exhausted.
                     // For each branch we fetch the commit date via the /branches/<name> detail endpoint.
@@ -84,8 +91,15 @@ pipeline {
                                 error("GitHub API did not return commit date for branch '${b.name}' - response may be malformed")
                             }
                             def commitDate = branchDetail.commit.commit.committer.date  // ISO-8601
-                            def commitInstant = java.time.Instant.parse(commitDate)
-                            if (!commitInstant.isBefore(threeMonthsAgo)) {
+                            def commitEpochStr = sh(
+                                script: "date -d '${commitDate}' +%s",
+                                returnStdout: true
+                            ).trim()
+                            if (!commitEpochStr.isLong()) {
+                                error("Failed to parse commit date for branch '${b.name}': 'date -d ${commitDate}' returned unexpected output: '${commitEpochStr}'")
+                            }
+                            def commitEpoch = commitEpochStr as long
+                            if (commitEpoch >= threeMonthsAgoEpoch) {
                                 echo "Active branch: ${b.name} (last commit: ${commitDate})"
                                 branches.add(b.name)
                             } else {

From 243e513b156a0937f6689534b180e507917049be Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Tue, 25 Aug 2026 10:26:10 +0100
Subject: [PATCH 08/27] fix(mirror_cspu): fetch skara remote before branch
 checkout to ensure correct base

Co-authored-by: Bob <bob@ibm.com>
---
 skaraMirror.sh | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/skaraMirror.sh b/skaraMirror.sh
index 2a50f31..dcba45c 100755
--- a/skaraMirror.sh
+++ b/skaraMirror.sh
@@ -44,21 +44,28 @@ function addSkaralUpstream() {
   cd "$WORKSPACE/$GITHUB_REPO" || exit 1
 
   git fetch --all
-  if ! git checkout -f "$BRANCH" ; then
-    if ! git rev-parse -q --verify "origin/$BRANCH" ; then
-      git checkout -b "$BRANCH" || exit 1
-    else
-      git checkout -b "$BRANCH" origin/"$BRANCH" || exit 1
-    fi
-  else
-    git reset --hard origin/"$BRANCH" || echo "Not resetting as no upstream exists"
-  fi
 
+  # Ensure the skara remote exists before we need it
   # shellcheck disable=SC2143
   if [ -z "$(git remote -v | grep 'skara')" ] ; then
     echo "Initial setup of $SKARA_REPO"
     git remote add skara "$SKARA_REPO"
   fi
+
+  # Fetch skara so skara/$BRANCH is available for branch creation below
+  git fetch skara
+
+  if ! git checkout -f "$BRANCH" ; then
+    if ! git rev-parse -q --verify "origin/$BRANCH" ; then
+      # Branch does not exist locally or on origin — create it from skara/$BRANCH
+      # so it starts at the correct upstream commit, not the current HEAD
+      git checkout -b "$BRANCH" "skara/$BRANCH" || exit 1
+    else
+      git checkout -b "$BRANCH" "origin/$BRANCH" || exit 1
+    fi
+  else
+    git reset --hard "origin/$BRANCH" || echo "Not resetting as no upstream exists"
+  fi
 }
 
 function performMergeFromSkaraIntoGit() {

From 2b545200e362204faba3c4d21a2978c0363eb1c4 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Tue, 25 Aug 2026 10:40:58 +0100
Subject: [PATCH 09/27] ci(mirror_cspu): add clean mirror workspace stage with
 conditional param

Co-authored-by: Bob <bob@ibm.com>
---
 Jenkinsfile | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/Jenkinsfile b/Jenkinsfile
index f07ccde..47b3db3 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -119,6 +119,19 @@ pipeline {
             }
         }
 
+        stage('Clean Mirror Workspace') {
+            when {
+                expression { return params.CLEAN_MIRROR_WORKSPACE == true }
+            }
+            steps {
+                script {
+                    def workspaceDir = "${env.WORKSPACE}/workspace/${params.JDK_VERSION}"
+                    echo "Cleaning mirror workspace: ${workspaceDir}"
+                    sh "rm -rf '${workspaceDir}'"
+                }
+            }
+        }
+
         stage('Mirror Branches') {
             steps {
                 script {

From 9fd6c90e6802d08fe83c9280c074cbe089f982ae Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Tue, 25 Aug 2026 11:00:14 +0100
Subject: [PATCH 10/27] fix(mirror_cspu): skip reset when origin branch does
 not exist yet

Co-authored-by: Bob <bob@ibm.com>
---
 skaraMirror.sh | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/skaraMirror.sh b/skaraMirror.sh
index dcba45c..6636b9f 100755
--- a/skaraMirror.sh
+++ b/skaraMirror.sh
@@ -64,7 +64,12 @@ function addSkaralUpstream() {
       git checkout -b "$BRANCH" "origin/$BRANCH" || exit 1
     fi
   else
-    git reset --hard "origin/$BRANCH" || echo "Not resetting as no upstream exists"
+    # Only reset to origin/$BRANCH if it has been pushed there previously
+    if git rev-parse -q --verify "origin/$BRANCH" ; then
+      git reset --hard "origin/$BRANCH" || exit 1
+    else
+      echo "No origin/$BRANCH exists yet, skipping reset"
+    fi
   fi
 }
 

From 62ea72c93b9d546b1214035ea14c56f199ca75b8 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Tue, 25 Aug 2026 13:56:27 +0100
Subject: [PATCH 11/27] refactor(mirror_cspu): replace GitHub API calls with
 git ls-remote and bare clone for branch discovery

Co-authored-by: Bob <bob@ibm.com>
---
 Jenkinsfile    | 104 +++++++++++++++++++++++--------------------------
 skaraMirror.sh |   6 +--
 2 files changed, 52 insertions(+), 58 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 47b3db3..e9b9ebd 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -40,81 +40,75 @@ pipeline {
                     def skaraRepo = "https://github.com/openjdk/${params.JDK_VERSION}"
                     echo "Upstream SKARA_REPO: ${skaraRepo}"
 
-                    // Fetch the default branch name and all active branches via the GitHub API.
-                    // "Active" branches match GitHub's own definition: last commit within 3 months,
-                    // which is the threshold used on the GitHub branches summary page.
-                    def apiBase = "https://api.github.com/repos/openjdk/${params.JDK_VERSION}"
-
-                    // Retrieve default branch
-                    def repoInfoJson = sh(
-                        script: "curl -fsSL '${apiBase}'",
+                    // Determine default branch via git ls-remote --symref (no API token needed)
+                    def symrefOutput = sh(
+                        script: "git ls-remote --symref '${skaraRepo}' HEAD",
                         returnStdout: true
                     ).trim()
-                    def repoInfo = readJSON text: repoInfoJson
-                    if (!repoInfo.default_branch) {
-                        error("GitHub API did not return a default_branch for openjdk/${params.JDK_VERSION} - response may be malformed")
+                    def defaultBranchMatch = symrefOutput =~ /ref: refs\/heads\/(\S+)\s+HEAD/
+                    if (!defaultBranchMatch) {
+                        error("Could not determine default branch for ${skaraRepo} - git ls-remote --symref output was unexpected:\n${symrefOutput}")
                     }
-                    def defaultBranch = repoInfo.default_branch
+                    def defaultBranch = defaultBranchMatch[0][1]
                     echo "Default branch: ${defaultBranch}"
 
-                    // Staleness threshold: unix timestamp 90 days ago, computed via shell (sandbox-safe)
-                    def threeMonthsAgoStr = sh(
-                        script: "date -d '90 days ago' +%s",
-                        returnStdout: true
-                    ).trim()
-                    if (!threeMonthsAgoStr.isLong()) {
-                        error("Failed to compute staleness threshold: 'date -d 90 days ago' returned unexpected output: '${threeMonthsAgoStr}'")
-                    }
-                    def threeMonthsAgoEpoch = threeMonthsAgoStr as long
-
-                    // Retrieve all branches and filter to active (non-stale) ones — paginate until exhausted.
-                    // For each branch we fetch the commit date via the /branches/<name> detail endpoint.
-                    // Use a for loop (not .each{}) so that any curl/parse failure propagates immediately.
-                    def branches = [] as Set
-                    def page = 1
-                    while (true) {
-                        def pageJson = sh(
-                            script: "curl -fsSL '${apiBase}/branches?per_page=100&page=${page}'",
+                    // Do a temporary bare clone with --filter=blob:none to get branch refs and
+                    // commit dates without downloading any file content.
+                    def tmpBareClone = "${env.WORKSPACE}/tmp-bare-${params.JDK_VERSION}"
+                    sh "rm -rf '${tmpBareClone}'"
+                    sh "git clone --bare --filter=blob:none '${skaraRepo}' '${tmpBareClone}'"
+
+                    try {
+                        // Staleness threshold: 90 days ago as unix epoch
+                        def threeMonthsAgoStr = sh(
+                            script: "date -d '90 days ago' +%s",
                             returnStdout: true
                         ).trim()
-                        def pageBranches = readJSON text: pageJson
-                        if (pageBranches.isEmpty()) {
-                            break
+                        if (!threeMonthsAgoStr.isLong()) {
+                            error("Failed to compute staleness threshold: unexpected output: '${threeMonthsAgoStr}'")
                         }
-                        for (b in pageBranches) {
-                            def branchDetailJson = sh(
-                                script: "curl -fsSL '${apiBase}/branches/${b.name}'",
-                                returnStdout: true
-                            ).trim()
-                            def branchDetail = readJSON text: branchDetailJson
-                            if (!branchDetail?.commit?.commit?.committer?.date) {
-                                error("GitHub API did not return commit date for branch '${b.name}' - response may be malformed")
-                            }
-                            def commitDate = branchDetail.commit.commit.committer.date  // ISO-8601
+                        def threeMonthsAgoEpoch = threeMonthsAgoStr as long
+
+                        // List all remote branches from the bare clone
+                        def allBranchesRaw = sh(
+                            script: "git -C '${tmpBareClone}' for-each-ref --format='%(refname:short)' refs/heads/",
+                            returnStdout: true
+                        ).trim()
+                        if (!allBranchesRaw) {
+                            error("No branches found in ${skaraRepo}")
+                        }
+
+                        // Filter to active branches by checking last commit date
+                        def branches = [] as Set
+                        for (branch in allBranchesRaw.split('\n')) {
+                            branch = branch.trim()
+                            if (!branch) continue
                             def commitEpochStr = sh(
-                                script: "date -d '${commitDate}' +%s",
+                                script: "git -C '${tmpBareClone}' log -1 --format='%ct' '${branch}'",
                                 returnStdout: true
                             ).trim()
                             if (!commitEpochStr.isLong()) {
-                                error("Failed to parse commit date for branch '${b.name}': 'date -d ${commitDate}' returned unexpected output: '${commitEpochStr}'")
+                                error("Could not determine commit date for branch '${branch}': unexpected output: '${commitEpochStr}'")
                             }
                             def commitEpoch = commitEpochStr as long
                             if (commitEpoch >= threeMonthsAgoEpoch) {
-                                echo "Active branch: ${b.name} (last commit: ${commitDate})"
-                                branches.add(b.name)
+                                echo "Active branch: ${branch} (epoch: ${commitEpoch})"
+                                branches.add(branch)
                             } else {
-                                echo "Stale branch (skipping): ${b.name} (last commit: ${commitDate})"
+                                echo "Stale branch (skipping): ${branch} (epoch: ${commitEpoch})"
                             }
                         }
-                        page++
-                    }
 
-                    // Ensure the default branch is always included
-                    branches.add(defaultBranch)
+                        // Ensure the default branch is always included
+                        branches.add(defaultBranch)
 
-                    echo "Active branches to mirror: ${branches.join(', ')}"
-                    env.BRANCHES_TO_MIRROR = branches.join(' ')
-                    env.DEFAULT_BRANCH     = defaultBranch
+                        echo "Active branches to mirror: ${branches.join(', ')}"
+                        env.BRANCHES_TO_MIRROR = branches.join(' ')
+                        env.DEFAULT_BRANCH     = defaultBranch
+                    } finally {
+                        // Always clean up the temporary bare clone
+                        sh "rm -rf '${tmpBareClone}'"
+                    }
                 }
             }
         }
diff --git a/skaraMirror.sh b/skaraMirror.sh
index 6636b9f..af4e103 100755
--- a/skaraMirror.sh
+++ b/skaraMirror.sh
@@ -280,10 +280,10 @@ SKARA_REPO="https://github.com/openjdk/$1"
 GITHUB_REPO="$1"
 REPO=${2:-"git@github.com:adoptium/$GITHUB_REPO"}
 
-# Determine the default branch of the upstream Skara repo
-SKARA_DEFAULT_BRANCH=$(curl -fsSL "https://api.github.com/repos/openjdk/${GITHUB_REPO}" | grep '"default_branch"' | head -1 | sed 's/.*"default_branch": *"\([^"]*\)".*/\1/' | tr -d '[:space:]')
+# Determine the default branch of the upstream Skara repo via git ls-remote (no API token needed)
+SKARA_DEFAULT_BRANCH=$(git ls-remote --symref "${SKARA_REPO}" HEAD | grep '^ref:' | sed 's|ref: refs/heads/||;s/[[:space:]].*//' | tr -d '[:space:]')
 if [[ -z "${SKARA_DEFAULT_BRANCH}" ]]; then
-  echo "ERROR: Could not determine default branch for openjdk/${GITHUB_REPO} - GitHub API response was empty or unexpected"
+  echo "ERROR: Could not determine default branch for ${SKARA_REPO} - git ls-remote --symref returned unexpected output"
   exit 1
 fi
 echo "Upstream default branch: ${SKARA_DEFAULT_BRANCH}"

From 69d715897c29d85a2df0e95aed98a69a01882e62 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Tue, 25 Aug 2026 16:59:04 +0100
Subject: [PATCH 12/27] Remove redundent ppc64le jdk8u patches

Signed-off-by: Andrew Leonard <andrew.m.leonard@ibm.com>
---
 patches/jdk8u/0001-Backport-8073139.patch |  40 ----
 patches/jdk8u/ppc64le_1.patch             | 221 ----------------------
 patches/jdk8u/ppc64le_2.patch             |  49 -----
 3 files changed, 310 deletions(-)
 delete mode 100644 patches/jdk8u/0001-Backport-8073139.patch
 delete mode 100644 patches/jdk8u/ppc64le_1.patch
 delete mode 100644 patches/jdk8u/ppc64le_2.patch

diff --git a/patches/jdk8u/0001-Backport-8073139.patch b/patches/jdk8u/0001-Backport-8073139.patch
deleted file mode 100644
index c185ede..0000000
--- a/patches/jdk8u/0001-Backport-8073139.patch
+++ /dev/null
@@ -1,40 +0,0 @@
-From 058ba9a0c163eeb4ae80d922a9102a4dbd5ccb0a Mon Sep 17 00:00:00 2001
-From: John Oliver <johno@insightfullogic.com>
-Date: Thu, 1 Nov 2018 14:05:55 +0000
-Subject: [PATCH] Backport 8073139
-
----
- common/autoconf/flags.m4       | 3 +++
- common/autoconf/jdk-options.m4 | 2 +-
- 2 files changed, 4 insertions(+), 1 deletion(-)
-
-diff --git a/common/autoconf/flags.m4 b/common/autoconf/flags.m4
-index c586b7f..93dc715 100644
---- a/common/autoconf/flags.m4
-+++ b/common/autoconf/flags.m4
-@@ -532,6 +532,9 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
-       CCXXFLAGS_JDK="$CCXXFLAGS_JDK -D_BIG_ENDIAN"
-     fi
-   fi
-+  if test "x$OPENJDK_TARGET_CPU" = xppc64le; then
-+    CCXXFLAGS_JDK="$CCXXFLAGS_JDK -DABI_ELFv2"
-+  fi
-   
-   # Setup target OS define. Use OS target name but in upper case.
-   OPENJDK_TARGET_OS_UPPERCASE=`$ECHO $OPENJDK_TARGET_OS | $TR 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
-diff --git a/common/autoconf/jdk-options.m4 b/common/autoconf/jdk-options.m4
-index 35e04f3..9e5f3c0 100644
---- a/common/autoconf/jdk-options.m4
-+++ b/common/autoconf/jdk-options.m4
-@@ -158,7 +158,7 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_JVM_VARIANTS],
-   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue ; then
-     INCLUDE_SA=false
-   fi
--  if test "x$VAR_CPU" = xppc64 ; then
-+  if test "x$VAR_CPU" = xppc64 -o "x$VAR_CPU" = xppc64le ; then
-     INCLUDE_SA=false
-   fi
-   if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
--- 
-2.7.4
-
diff --git a/patches/jdk8u/ppc64le_1.patch b/patches/jdk8u/ppc64le_1.patch
deleted file mode 100644
index dddeaa7..0000000
--- a/patches/jdk8u/ppc64le_1.patch
+++ /dev/null
@@ -1,221 +0,0 @@
-From dd9fabc322bfd75ed2bec17c6d10e50ff402b6a4 Mon Sep 17 00:00:00 2001
-From: Martijn Verburg <martijnverburg@gmail.com>
-Date: Mon, 17 Sep 2018 15:12:55 +0100
-Subject: [PATCH] Apply backported patch from
- https://bugs.openjdk.java.net/browse/JDK-8073139
-
-Signed-off-by: Martijn Verburg <martijnverburg@gmail.com>
----
- common/autoconf/generated-configure.sh      |  7 +++++--
- common/autoconf/platform.m4                 |  2 +-
- hotspot/agent/src/os/linux/libproc.h        |  2 +-
- hotspot/make/defs.make                      | 12 +++++++++---
- hotspot/src/os/linux/vm/os_linux.cpp        |  2 +-
- hotspot/src/share/tools/hsdis/Makefile      |  1 +
- hotspot/src/share/tools/hsdis/hsdis-demo.c  |  2 +-
- hotspot/src/share/tools/hsdis/hsdis.c       |  2 +-
- hotspot/src/share/vm/runtime/vm_version.cpp |  9 +++++++--
- jdk/make/lib/SoundLibraries.gmk             |  5 +++++
- jdk/test/tools/launcher/Settings.java       |  2 +-
- 11 files changed, 33 insertions(+), 13 deletions(-)
-
-diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
-index caf4963a93..49b788d10e 100644
---- a/common/autoconf/generated-configure.sh
-+++ b/common/autoconf/generated-configure.sh
-@@ -13625,7 +13625,7 @@ test -n "$target_alias" &&
-       VAR_CPU_ENDIAN=big
-       ;;
-     powerpc64le)
--      VAR_CPU=ppc64
-+      VAR_CPU=ppc64le
-       VAR_CPU_ARCH=ppc
-       VAR_CPU_BITS=64
-       VAR_CPU_ENDIAN=little
-@@ -13763,7 +13763,7 @@ $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
-       VAR_CPU_ENDIAN=big
-       ;;
-     powerpc64le)
--      VAR_CPU=ppc64
-+      VAR_CPU=ppc64le
-       VAR_CPU_ARCH=ppc
-       VAR_CPU_BITS=64
-       VAR_CPU_ENDIAN=little
-@@ -14586,6 +14586,9 @@ $as_echo "$with_jvm_variants" >&6; }
-   if test "x$VAR_CPU" = xppc64 ; then
-     INCLUDE_SA=false
-   fi
-+  if test "x$VAR_CPU" = xppc64le ; then
-+    INCLUDE_SA=false
-+  fi
-   if test "x$OPENJDK_TARGET_CPU" = xaarch64; then
-     INCLUDE_SA=false
-   fi
-diff --git a/common/autoconf/platform.m4 b/common/autoconf/platform.m4
-index bf109d5076..945579d606 100644
---- a/common/autoconf/platform.m4
-+++ b/common/autoconf/platform.m4
-@@ -67,7 +67,7 @@ AC_DEFUN([PLATFORM_EXTRACT_VARS_FROM_CPU],
-       VAR_CPU_ENDIAN=big
-       ;;
-     powerpc64le)
--      VAR_CPU=ppc64
-+      VAR_CPU=ppc64le
-       VAR_CPU_ARCH=ppc
-       VAR_CPU_BITS=64
-       VAR_CPU_ENDIAN=little
-diff --git a/hotspot/agent/src/os/linux/libproc.h b/hotspot/agent/src/os/linux/libproc.h
-index 03426c96ff..5d4ac3d2da 100644
---- a/hotspot/agent/src/os/linux/libproc.h
-+++ b/hotspot/agent/src/os/linux/libproc.h
-@@ -68,7 +68,7 @@ combination of ptrace and /proc calls.
- *************************************************************************************/
- 
- 
--#if defined(sparc) || defined(sparcv9) || defined(ppc64)
-+#if defined(sparc) || defined(sparcv9) || defined(ppc64) || defined(ppc64le)
- #include <asm/ptrace.h>
- #define user_regs_struct  pt_regs
- #endif
-diff --git a/hotspot/make/defs.make b/hotspot/make/defs.make
-index b5a41239cc..e553575dd6 100644
---- a/hotspot/make/defs.make
-+++ b/hotspot/make/defs.make
-@@ -285,7 +285,7 @@ ifneq ($(OSNAME),windows)
- 
-   # Use uname output for SRCARCH, but deal with platform differences. If ARCH
-   # is not explicitly listed below, it is treated as x86.
--  SRCARCH    ?= $(ARCH/$(filter sparc sparc64 ia64 amd64 x86_64 ppc ppc64 zero,$(ARCH)))
-+  SRCARCH    ?= $(ARCH/$(filter sparc sparc64 ia64 amd64 x86_64 ppc ppc64 ppc64le zero,$(ARCH)))
-   ARCH/       = x86
-   ARCH/sparc  = sparc
-   ARCH/sparc64= sparc
-@@ -293,6 +293,7 @@ ifneq ($(OSNAME),windows)
-   ARCH/amd64  = x86
-   ARCH/x86_64 = x86
-   ARCH/ppc64  = ppc
-+  ARCH/ppc64le= ppc
-   ARCH/ppc    = ppc
-   ARCH/zero   = zero
- 
-@@ -316,8 +317,13 @@ ifneq ($(OSNAME),windows)
-     endif
-   endif
- 
--  # LIBARCH is 1:1 mapping from BUILDARCH
--  LIBARCH        ?= $(LIBARCH/$(BUILDARCH))
-+  # LIBARCH is 1:1 mapping from BUILDARCH, except for ARCH=ppc64le
-+  ifeq ($(ARCH),ppc64le)
-+    LIBARCH      ?= ppc64le
-+  else
-+    LIBARCH      ?= $(LIBARCH/$(BUILDARCH))
-+  endif
-+
-   LIBARCH/i486    = i386
-   LIBARCH/amd64   = amd64
-   LIBARCH/sparc   = sparc
-diff --git a/hotspot/src/os/linux/vm/os_linux.cpp b/hotspot/src/os/linux/vm/os_linux.cpp
-index d297445dc9..387ff03649 100644
---- a/hotspot/src/os/linux/vm/os_linux.cpp
-+++ b/hotspot/src/os/linux/vm/os_linux.cpp
-@@ -1956,7 +1956,7 @@ void * os::dll_load(const char *filename, char *ebuf, int ebuflen)
-     {EM_SPARCV9,     EM_SPARCV9, ELFCLASS64, ELFDATA2MSB, (char*)"Sparc v9 64"},
-     {EM_PPC,         EM_PPC,     ELFCLASS32, ELFDATA2MSB, (char*)"Power PC 32"},
- #if defined(VM_LITTLE_ENDIAN)
--    {EM_PPC64,       EM_PPC64,   ELFCLASS64, ELFDATA2LSB, (char*)"Power PC 64"},
-+    {EM_PPC64,       EM_PPC64,   ELFCLASS64, ELFDATA2LSB, (char*)"Power PC 64 LE"},
- #else
-     {EM_PPC64,       EM_PPC64,   ELFCLASS64, ELFDATA2MSB, (char*)"Power PC 64"},
- #endif
-diff --git a/hotspot/src/share/tools/hsdis/Makefile b/hotspot/src/share/tools/hsdis/Makefile
-index 35e96d8a31..0d1b608944 100644
---- a/hotspot/src/share/tools/hsdis/Makefile
-+++ b/hotspot/src/share/tools/hsdis/Makefile
-@@ -97,6 +97,7 @@ ifdef LP64
- CFLAGS/sparcv9	+= -m64
- CFLAGS/amd64	+= -m64
- CFLAGS/ppc64	+= -m64
-+CFLAGS/ppc64le  += -m64 -DABI_ELFv2
- else
- ARCH=$(ARCH1:amd64=i386)
- CFLAGS/i386	+= -m32
-diff --git a/hotspot/src/share/tools/hsdis/hsdis-demo.c b/hotspot/src/share/tools/hsdis/hsdis-demo.c
-index 3037a4b7b9..bf4499ae67 100644
---- a/hotspot/src/share/tools/hsdis/hsdis-demo.c
-+++ b/hotspot/src/share/tools/hsdis/hsdis-demo.c
-@@ -142,7 +142,7 @@ static const char* load_decode_instructions() {
- 
- 
- static const char* lookup(void* addr) {
--#if defined(__ia64) || defined(__powerpc__)
-+#if defined(__ia64) || (defined(__powerpc__) && !defined(ABI_ELFv2))
-   /* On IA64 and PPC function pointers are pointers to function descriptors */
- #define CHECK_NAME(fn) \
-   if (addr == *((void**) &fn))  return #fn;
-diff --git a/hotspot/src/share/tools/hsdis/hsdis.c b/hotspot/src/share/tools/hsdis/hsdis.c
-index 430de855b8..7bef1040fb 100644
---- a/hotspot/src/share/tools/hsdis/hsdis.c
-+++ b/hotspot/src/share/tools/hsdis/hsdis.c
-@@ -488,7 +488,7 @@ static const char* native_arch_name() {
- #ifdef LIBARCH_sparcv9
-   res = "sparc:v9b";
- #endif
--#ifdef LIBARCH_ppc64
-+#if defined(LIBARCH_ppc64) || defined(LIBARCH_ppc64le)
-   res = "powerpc:common64";
- #endif
-   if (res == NULL)
-diff --git a/hotspot/src/share/vm/runtime/vm_version.cpp b/hotspot/src/share/vm/runtime/vm_version.cpp
-index 445f1b8465..c41d104d21 100644
---- a/hotspot/src/share/vm/runtime/vm_version.cpp
-+++ b/hotspot/src/share/vm/runtime/vm_version.cpp
-@@ -184,13 +184,18 @@ const char* Abstract_VM_Version::jre_release_version() {
- #ifndef CPU
- #ifdef ZERO
- #define CPU      ZERO_LIBARCH
-+#elif defined(PPC64)
-+#if defined(VM_LITTLE_ENDIAN)
-+#define CPU      "ppc64le"
-+#else
-+#define CPU      "ppc64"
-+#endif
- #else
- #define CPU      IA32_ONLY("x86")                \
-                  IA64_ONLY("ia64")               \
-                  AMD64_ONLY("amd64")             \
--                 PPC64_ONLY("ppc64")             \
-                  SPARC_ONLY("sparc")
--#endif // ZERO
-+#endif
- #endif
- 
- const char *Abstract_VM_Version::vm_platform_string() {
-diff --git a/jdk/make/lib/SoundLibraries.gmk b/jdk/make/lib/SoundLibraries.gmk
-index 14580959cc..f22c9825e4 100644
---- a/jdk/make/lib/SoundLibraries.gmk
-+++ b/jdk/make/lib/SoundLibraries.gmk
-@@ -139,6 +139,11 @@ else
-   ifeq ($(OPENJDK_TARGET_CPU), ppc64)
-        LIBJSOUND_CFLAGS += -DX_ARCH=X_PPC64
-   endif
-+
-+  ifeq ($(OPENJDK_TARGET_CPU), ppc64le)
-+       LIBJSOUND_CFLAGS += -DX_ARCH=X_PPC64LE
-+  endif
-+
- endif
- 
- LIBJSOUND_CFLAGS += -DEXTRA_SOUND_JNI_LIBS='"$(EXTRA_SOUND_JNI_LIBS)"'
-diff --git a/jdk/test/tools/launcher/Settings.java b/jdk/test/tools/launcher/Settings.java
-index 16fd29b0b1..8d45c8288b 100644
---- a/jdk/test/tools/launcher/Settings.java
-+++ b/jdk/test/tools/launcher/Settings.java
-@@ -74,7 +74,7 @@ static void containsAllOptions(TestResult tr) {
- 
-     static void runTestOptionDefault() throws IOException {
-         String stackSize = "256"; // in kb
--        if (getArch().equals("ppc64")) {
-+        if (getArch().equals("ppc64") || getArch().equals("ppc64le")) {
-             stackSize = "800";
-         }
-         TestResult tr = null;
diff --git a/patches/jdk8u/ppc64le_2.patch b/patches/jdk8u/ppc64le_2.patch
deleted file mode 100644
index 3d87942..0000000
--- a/patches/jdk8u/ppc64le_2.patch
+++ /dev/null
@@ -1,49 +0,0 @@
-From 8b40b63897b02866e74cb224097c7fafc86b468d Mon Sep 17 00:00:00 2001
-From: Martijn Verburg <martijnverburg@gmail.com>
-Date: Mon, 17 Sep 2018 16:29:34 +0100
-Subject: [PATCH] add missing jvm.cfg file
-
----
- jdk/src/solaris/bin/ppc64le/jvm.cfg | 33 +++++++++++++++++++++++++++++
- 1 file changed, 33 insertions(+)
- create mode 100644 jdk/src/solaris/bin/ppc64le/jvm.cfg
-
-diff --git a/jdk/src/solaris/bin/ppc64le/jvm.cfg b/jdk/src/solaris/bin/ppc64le/jvm.cfg
-new file mode 100644
-index 0000000000..2fc1214175
---- /dev/null
-+++ b/jdk/src/solaris/bin/ppc64le/jvm.cfg
-@@ -0,0 +1,33 @@
-+# Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
-+# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
-+#
-+# This code is free software; you can redistribute it and/or modify it
-+# under the terms of the GNU General Public License version 2 only, as
-+# published by the Free Software Foundation.  Oracle designates this
-+# particular file as subject to the "Classpath" exception as provided
-+# by Oracle in the LICENSE file that accompanied this code.
-+#
-+# This code is distributed in the hope that it will be useful, but WITHOUT
-+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-+# FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-+# version 2 for more details (a copy is included in the LICENSE file that
-+# accompanied this code).
-+#
-+# You should have received a copy of the GNU General Public License version
-+# 2 along with this work; if not, write to the Free Software Foundation,
-+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
-+#
-+# Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
-+# or visit www.oracle.com if you need additional information or have any
-+# questions.
-+#
-+# List of JVMs that can be used as an option to java, javac, etc.
-+# Order is important -- first in this list is the default JVM.
-+# NOTE that this both this file and its format are UNSUPPORTED and
-+# WILL GO AWAY in a future release.
-+#
-+# You may also select a JVM in an arbitrary location with the
-+# "-XXaltjvm=<jvm_dir>" option, but that too is unsupported
-+# and may not be available in a future release.
-+#
-+-server KNOWN

From 9555a4cb6f75f488c88b0c48ffdaa7c07f0c87e3 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Wed, 26 Aug 2026 10:22:47 +0100
Subject: [PATCH 13/27] fix(mirror_cspu): apply repo patches and handle missing
 dev branch

Co-authored-by: Bob <bob@ibm.com>
---
 .../actions-ignore-branches.patch             |  0
 patches/jdk11u/actions-ignore-branches.patch  |  0
 patches/jdk17u/actions-ignore-branches.patch  | 24 ++++++++
 patches/jdk8u/actions-ignore-branches.patch   |  0
 skaraMirror.sh                                | 55 +++++++++++++------
 5 files changed, 62 insertions(+), 17 deletions(-)
 create mode 100644 patches/aarch32-port-jdk8u/actions-ignore-branches.patch
 create mode 100644 patches/jdk11u/actions-ignore-branches.patch
 create mode 100644 patches/jdk17u/actions-ignore-branches.patch
 create mode 100644 patches/jdk8u/actions-ignore-branches.patch

diff --git a/patches/aarch32-port-jdk8u/actions-ignore-branches.patch b/patches/aarch32-port-jdk8u/actions-ignore-branches.patch
new file mode 100644
index 0000000..e69de29
diff --git a/patches/jdk11u/actions-ignore-branches.patch b/patches/jdk11u/actions-ignore-branches.patch
new file mode 100644
index 0000000..e69de29
diff --git a/patches/jdk17u/actions-ignore-branches.patch b/patches/jdk17u/actions-ignore-branches.patch
new file mode 100644
index 0000000..47ebe24
--- /dev/null
+++ b/patches/jdk17u/actions-ignore-branches.patch
@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Adoptium <adoptium-mirrors@eclipse.org>
+Date: Mon, 17 Sep 2001 00:00:00 +0000
+Subject: [PATCH] skip github actions builds to save executors
+
+---
+ .github/workflows/main.yml | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
+index 4e1957194b9..416878cc4c9 100644
+--- a/.github/workflows/main.yml
++++ b/.github/workflows/main.yml
+@@ -29,6 +29,8 @@ on:
+   push:
+     branches-ignore:
+       - master
++      - dev*
++      - release*
+       - pr/*
+   workflow_dispatch:
+     inputs:
+-- 
+2.39.0
diff --git a/patches/jdk8u/actions-ignore-branches.patch b/patches/jdk8u/actions-ignore-branches.patch
new file mode 100644
index 0000000..e69de29
diff --git a/skaraMirror.sh b/skaraMirror.sh
index af4e103..aebcf34 100755
--- a/skaraMirror.sh
+++ b/skaraMirror.sh
@@ -108,22 +108,35 @@ function performMergeIntoReleaseFromMaster() {
     git reset --hard "origin/$RELEASE_BRANCH" || echo "Not resetting as no upstream exists"
   fi
 
-  # Apply our patches to release branch
-  echo "Checking if patches need to be applied for $GITHUB_REPO"
-
-  # actions ignore branch patch is for > jdk11u
-  if [[ "$GITHUB_REPO" != "jdk8u" ]] && [[ "$GITHUB_REPO" != "aarch32-port-jdk8u" ]] && [[ "$GITHUB_REPO" != "jdk11u" ]]; then
-    # check to see if patch has already been applied
-    if ! grep -q "\\- dev" "$WORKSPACE/$GITHUB_REPO/.github/workflows/main.yml"; then
-      echo "Applying actions-ignore-branches.patch"
-      git am $PATCHES/actions-ignore-branches.patch
-    fi
-  fi
-
-  # README.JAVASE patch needed for all repos
+  # Apply Adoptium patches to release branch, gated on README.JAVASE not existing
+  # (README.JAVASE is the Adoptium marker file — its absence means no patches have been applied yet)
   if [ ! -f "$WORKSPACE/$GITHUB_REPO/README.JAVASE" ]; then
-    echo "Applying README.JAVASE.patch"
-    git am $PATCHES/readme-javase.patch
+    echo "Applying Adoptium patches for $GITHUB_REPO"
+
+    # Step 1: Apply top-level patches, skipping any whose filename also exists in patches/<GITHUB_REPO>/
+    # (repo-specific patches in the sub-folder take precedence and will be applied in step 2)
+    for patchFile in "$PATCHES"*.patch; do
+      [ -f "$patchFile" ] || continue
+      patchName=$(basename "$patchFile")
+      if [ -f "$PATCHES$GITHUB_REPO/$patchName" ]; then
+        echo "Skipping top-level $patchName (overridden by patches/$GITHUB_REPO/$patchName)"
+      else
+        echo "Applying top-level patch: $patchName"
+        git am "$patchFile" || exit 1
+      fi
+    done
+
+    # Step 2: Apply repo-specific patches from patches/<GITHUB_REPO>/ if that folder exists
+    if [ -d "$PATCHES$GITHUB_REPO" ]; then
+      for patchFile in "$PATCHES$GITHUB_REPO"/*.patch; do
+        [ -f "$patchFile" ] || continue
+        patchName=$(basename "$patchFile")
+        echo "Applying repo-specific patch: $patchName"
+        git am "$patchFile" || exit 1
+      done
+    fi
+  else
+    echo "README.JAVASE already exists — patches already applied, skipping"
   fi
 
   # Find the latest release tag that is not in releaseTagExcludeList
@@ -244,12 +257,20 @@ function performMergeIntoDevFromMaster() {
 
   if ! git checkout -f "$DEV_BRANCH" ; then
     if ! git rev-parse -q --verify "origin/$DEV_BRANCH" ; then
-      git checkout -b "$DEV_BRANCH" || exit 1
+      # Branch does not exist locally or on origin — create it from $BRANCH (upstream default,
+      # already at latest HEAD from performMergeFromSkaraIntoGit), not from current HEAD
+      # which will be RELEASE_BRANCH after performMergeIntoReleaseFromMaster()
+      git checkout -b "$DEV_BRANCH" "$BRANCH" || exit 1
     else
       git checkout -b "$DEV_BRANCH" "origin/$DEV_BRANCH" || exit 1
     fi
   else
-    git reset --hard "origin/$DEV_BRANCH" || echo "Not resetting as no upstream exists"
+    # Only reset to origin/$DEV_BRANCH if it has been pushed there previously
+    if git rev-parse -q --verify "origin/$DEV_BRANCH" ; then
+      git reset --hard "origin/$DEV_BRANCH" || exit 1
+    else
+      echo "No origin/$DEV_BRANCH exists yet, skipping reset"
+    fi
   fi
 
   devTags=$(git tag --merged "$DEV_BRANCH" $TAG_SEARCH || exit 1)

From ed684f61740cd9fea353b791cd803d590ec3c526 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Wed, 26 Aug 2026 11:08:27 +0100
Subject: [PATCH 14/27] chore(mirror_cspu): add alpine-jdk8u patches and musl
 libc support

Co-authored-by: Bob <bob@ibm.com>
---
 ...ply-PATCH-Allow-setting-company-name.patch | 145 +++++++
 ...ly-0001-Set-vendor-information.patch.patch |  33 ++
 ...hub-actions-builds-to-save-executors.patch |  26 ++
 ...t-C-library-and-define-LIBC-variable.patch | 199 ++++++++++
 ...Change-glibc_version-to-libc_version.patch | 143 +++++++
 ...07-Don-t-build-SA-if-using-musl-libc.patch |  92 +++++
 ...Apply-Alpine-s-patches-for-musl-libc.patch | 360 ++++++++++++++++++
 ...ply-Alpine-s-ppc-patch-for-musl-libc.patch | 236 ++++++++++++
 .../0010-Update-includes-for-musl-libc.patch  | 317 +++++++++++++++
 ...SIGRTMAX-is-not-defined-in-musl-libc.patch |  56 +++
 ...emove-unused-print_stack-void-method.patch |  53 +++
 .../0013-Fix-separator-error-in-sa.make.patch |  25 ++
 ...x-includes-for-musl-on-linux-aarch64.patch |  25 ++
 ...15-Regenerate-generated-configure.sh.patch | 270 +++++++++++++
 ...nfigure.sh-as-contains-conflict-msgs.patch |  34 ++
 ...nfigure.sh-as-contains-conflict-msgs.patch |  26 ++
 ...or-in-MUSL-merge-conflict-resolution.patch |  61 +++
 .../actions-ignore-branches.patch             |   0
 skaraMirror.sh                                |  14 +-
 19 files changed, 2112 insertions(+), 3 deletions(-)
 create mode 100644 patches/alpine-jdk8u/0002-apply-PATCH-Allow-setting-company-name.patch
 create mode 100644 patches/alpine-jdk8u/0003-apply-0001-Set-vendor-information.patch.patch
 create mode 100644 patches/alpine-jdk8u/0004-skip-github-actions-builds-to-save-executors.patch
 create mode 100644 patches/alpine-jdk8u/0005-Detect-C-library-and-define-LIBC-variable.patch
 create mode 100644 patches/alpine-jdk8u/0006-Change-glibc_version-to-libc_version.patch
 create mode 100644 patches/alpine-jdk8u/0007-Don-t-build-SA-if-using-musl-libc.patch
 create mode 100644 patches/alpine-jdk8u/0008-Apply-Alpine-s-patches-for-musl-libc.patch
 create mode 100644 patches/alpine-jdk8u/0009-Apply-Alpine-s-ppc-patch-for-musl-libc.patch
 create mode 100644 patches/alpine-jdk8u/0010-Update-includes-for-musl-libc.patch
 create mode 100644 patches/alpine-jdk8u/0011-__SIGRTMAX-is-not-defined-in-musl-libc.patch
 create mode 100644 patches/alpine-jdk8u/0012-Remove-unused-print_stack-void-method.patch
 create mode 100644 patches/alpine-jdk8u/0013-Fix-separator-error-in-sa.make.patch
 create mode 100644 patches/alpine-jdk8u/0014-Fix-includes-for-musl-on-linux-aarch64.patch
 create mode 100644 patches/alpine-jdk8u/0015-Regenerate-generated-configure.sh.patch
 create mode 100644 patches/alpine-jdk8u/0016-Regen-generated-configure.sh-as-contains-conflict-msgs.patch
 create mode 100644 patches/alpine-jdk8u/0017-Regen-generated-configure.sh-as-contains-conflict-msgs.patch
 create mode 100644 patches/alpine-jdk8u/0018-Fix-error-in-MUSL-merge-conflict-resolution.patch
 create mode 100644 patches/alpine-jdk8u/actions-ignore-branches.patch

diff --git a/patches/alpine-jdk8u/0002-apply-PATCH-Allow-setting-company-name.patch b/patches/alpine-jdk8u/0002-apply-PATCH-Allow-setting-company-name.patch
new file mode 100644
index 0000000..9faf367
--- /dev/null
+++ b/patches/alpine-jdk8u/0002-apply-PATCH-Allow-setting-company-name.patch
@@ -0,0 +1,145 @@
+From 64e700caf63749a574abf84511420cc22c74217f Mon Sep 17 00:00:00 2001
+From: George Adams <georgeadams1995@gmail.com>
+Date: Mon, 6 Dec 2021 11:26:48 +0000
+Subject: [PATCH] apply [PATCH] Allow setting company name
+
+---
+ common/autoconf/generated-configure.sh        | 24 +++++++++++--------
+ common/autoconf/jdk-options.m4                | 12 ++++++++++
+ jdk/make/gensrc/GensrcMisc.gmk                |  6 +++++
+ .../classes/sun/misc/Version.java.template    |  7 ++++--
+ 4 files changed, 37 insertions(+), 12 deletions(-)
+
+diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
+index 71fabf4dbb..c926f7d75e 100644
+--- a/common/autoconf/generated-configure.sh
++++ b/common/autoconf/generated-configure.sh
+@@ -1067,6 +1067,7 @@ with_milestone
+ with_update_version
+ with_user_release_suffix
+ with_build_number
++with_company_name
+ with_vendor_name
+ with_vendor_url
+ with_vendor_bug_url
+@@ -1918,6 +1919,7 @@ Optional Packages:
+                           Add a custom string to the version string if build
+                           number isn't set.[username_builddateb00]
+   --with-build-number     Set build number value for build [b00]
++  --with-company-name     Set company name
+   --with-vendor-name      Set vendor name. Among others, used to set the
+                           'java.vendor' and 'java.vm.vendor' system
+                           properties. [not specified]
+@@ -20138,18 +20140,20 @@ fi
+ 
+   # Now set the JDK version, milestone, build number etc.
+ 
++  # The company name, if any
+ 
++# Check whether --with-company-name was given.
++if test "${with_company_name+set}" = set; then :
++  withval=$with_company_name;
++fi
+ 
+-
+-
+-
+-
+-
+-
+-
+-
+-
+-
++  if test "x$with_company_name" = xyes; then
++    as_fn_error $? "--with-company-name must have a value" "$LINENO" 5
++  elif  ! [[ $with_company_name =~ ^[[:print:]]*$ ]] ; then
++    as_fn_error $? "--with-company-name contains non-printing characters: $with_company_name" "$LINENO" 5
++  elif test "x$with_company_name" != x; then
++    COMPANY_NAME="$with_company_name"
++  fi
+ 
+   # The vendor name, if any
+ 
+diff --git a/common/autoconf/jdk-options.m4 b/common/autoconf/jdk-options.m4
+index 18ba585209..42aeb7bd61 100644
+--- a/common/autoconf/jdk-options.m4
++++ b/common/autoconf/jdk-options.m4
+@@ -539,6 +539,18 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_JDK_VERSION_NUMBERS],
+   AC_SUBST(MACOSX_BUNDLE_NAME_BASE)
+   AC_SUBST(MACOSX_BUNDLE_ID_BASE)
+ 
++  # The company name, if any
++  AC_ARG_WITH(company-name, [AS_HELP_STRING([--with-company-name],
++      [Set company name.])])
++  if test "x$with_company_name" = xyes; then
++    AC_MSG_ERROR([--with-company-name must have a value])
++  elif [ ! [[ $with_company_name =~ ^[[:print:]]*$ ]] ]; then
++    AC_MSG_ERROR([--with-company-name contains non-printing characters: $with_company_name])
++  elif test "x$with_company_name" != x; then
++    COMPANY_NAME="$with_company_name"
++  fi
++  AC_SUBST(COMPANY_NAME)
++
+   # The vendor name, if any
+   AC_ARG_WITH(vendor-name, [AS_HELP_STRING([--with-vendor-name],
+       [Set vendor name. Among others, used to set the 'java.vendor'
+diff --git a/jdk/make/gensrc/GensrcMisc.gmk b/jdk/make/gensrc/GensrcMisc.gmk
+index 0e3dee5ca3..fc19b082cc 100644
+--- a/jdk/make/gensrc/GensrcMisc.gmk
++++ b/jdk/make/gensrc/GensrcMisc.gmk
+@@ -30,6 +30,11 @@ include ProfileNames.gmk
+ # string and the runtime name into the Version.java file.
+ # To be printed by java -version
+ 
++company_name =
++ifneq ($(COMPANY_NAME),N/A)
++  company_name=($(COMPANY_NAME))
++endif
++
+ $(JDK_OUTPUTDIR)/gensrc/sun/misc/Version.java \
+ $(PROFILE_VERSION_JAVA_TARGETS): \
+     $(JDK_TOPDIR)/src/share/classes/sun/misc/Version.java.template
+@@ -41,6 +46,7 @@ $(PROFILE_VERSION_JAVA_TARGETS): \
+ 	    -e 's/@@java_runtime_version@@/$(FULL_VERSION)/g' \
+ 	    -e 's/@@java_runtime_name@@/$(RUNTIME_NAME)/g' \
+ 	    -e 's/@@java_profile_name@@/$(call profile_version_name, $@)/g' \
++      -e 's/@@company_name@@/$(company_name)/g' \
+ 	    $< > $@.tmp
+ 	$(MV) $@.tmp $@
+ 
+diff --git a/jdk/src/share/classes/sun/misc/Version.java.template b/jdk/src/share/classes/sun/misc/Version.java.template
+index 32e2586e79..b1642d3f0a 100644
+--- a/jdk/src/share/classes/sun/misc/Version.java.template
++++ b/jdk/src/share/classes/sun/misc/Version.java.template
+@@ -44,6 +44,9 @@ public class Version {
+     private static final String java_runtime_version =
+         "@@java_runtime_version@@";
+ 
++    private static final String company_name =
++        "@@company_name@@";
++
+     static {
+         init();
+     }
+@@ -103,7 +106,7 @@ public class Version {
+ 
+         /* Second line: runtime version (ie, libraries). */
+ 
+-        ps.print(java_runtime_name + " (build " + java_runtime_version);
++        ps.print(java_runtime_name + " " + company_name + "(build " + java_runtime_version);
+ 
+         if (java_profile_name.length() > 0) {
+             // profile name
+@@ -120,7 +123,7 @@ public class Version {
+         String java_vm_name    = System.getProperty("java.vm.name");
+         String java_vm_version = System.getProperty("java.vm.version");
+         String java_vm_info    = System.getProperty("java.vm.info");
+-        ps.println(java_vm_name + " (build " + java_vm_version + ", " +
++        ps.println(java_vm_name + " " + company_name + "(build " + java_vm_version + ", " +
+                    java_vm_info + ")");
+     }
+ 
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0003-apply-0001-Set-vendor-information.patch.patch b/patches/alpine-jdk8u/0003-apply-0001-Set-vendor-information.patch.patch
new file mode 100644
index 0000000..c07a405
--- /dev/null
+++ b/patches/alpine-jdk8u/0003-apply-0001-Set-vendor-information.patch.patch
@@ -0,0 +1,33 @@
+From d3b53e6f024d33acce72076d3e2475bf498304b2 Mon Sep 17 00:00:00 2001
+From: George Adams <georgeadams1995@gmail.com>
+Date: Mon, 6 Dec 2021 11:08:49 +0000
+Subject: [PATCH] apply 0001-Set-vendor-information.patch
+
+---
+ jdk/src/share/native/java/lang/System.c | 6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+diff --git a/jdk/src/share/native/java/lang/System.c b/jdk/src/share/native/java/lang/System.c
+index 85dbe575cb..4091b71b82 100644
+--- a/jdk/src/share/native/java/lang/System.c
++++ b/jdk/src/share/native/java/lang/System.c
+@@ -110,13 +110,13 @@ Java_java_lang_System_identityHashCode(JNIEnv *env, jobject this, jobject x)
+ 
+ /* Third party may overwrite these values. */
+ #ifndef VENDOR
+-#define VENDOR "Oracle Corporation"
++#define VENDOR "Eclipse Foundation"
+ #endif
+ #ifndef VENDOR_URL
+-#define VENDOR_URL "http://java.oracle.com/"
++#define VENDOR_URL "https://adoptium.net/"
+ #endif
+ #ifndef VENDOR_URL_BUG
+-#define VENDOR_URL_BUG "http://bugreport.sun.com/bugreport/"
++#define VENDOR_URL_BUG "https://github.com/adoptium/adoptium-support/issues"
+ #endif
+ 
+ #define JAVA_MAX_SUPPORTED_VERSION 52
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0004-skip-github-actions-builds-to-save-executors.patch b/patches/alpine-jdk8u/0004-skip-github-actions-builds-to-save-executors.patch
new file mode 100644
index 0000000..2a90884
--- /dev/null
+++ b/patches/alpine-jdk8u/0004-skip-github-actions-builds-to-save-executors.patch
@@ -0,0 +1,26 @@
+From c7c6920811bf5efda3111893fa335d4f4dd0a495 Mon Sep 17 00:00:00 2001
+From: George Adams <georgeadams1995@gmail.com>
+Date: Thu, 12 Jan 2023 22:16:09 +0000
+Subject: [PATCH] skip github actions builds to save executors
+
+Currently, every time the mirror job runs we end up running GitHub actions builds on all platforms for every commit on both dev and release which ends up burning through our allowance. This PR adds the branches-ignore flag to both branches as we know the code is safe from master.
+---
+ .github/workflows/submit.yml | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/.github/workflows/submit.yml b/.github/workflows/submit.yml
+index 87e49481f5..e998d6fe90 100644
+--- a/.github/workflows/submit.yml
++++ b/.github/workflows/submit.yml
+@@ -4,6 +4,8 @@ on:
+   push:
+     branches-ignore:
+       - master
++      - dev*
++      - release*
+       - pr/*
+   workflow_dispatch:
+     inputs:
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0005-Detect-C-library-and-define-LIBC-variable.patch b/patches/alpine-jdk8u/0005-Detect-C-library-and-define-LIBC-variable.patch
new file mode 100644
index 0000000..7808a5d
--- /dev/null
+++ b/patches/alpine-jdk8u/0005-Detect-C-library-and-define-LIBC-variable.patch
@@ -0,0 +1,199 @@
+From 129e671a46a50cde80f7aca76fcff8c1357fcd30 Mon Sep 17 00:00:00 2001
+From: Stephanie Crater <scrater@microsoft.com>
+Date: Mon, 7 Mar 2022 17:19:27 -0800
+Subject: [PATCH] Detect C library and define LIBC variable
+
+---
+ common/autoconf/build-aux/config.guess | 11 ++++++++
+ common/autoconf/build-aux/config.sub   |  5 ++++
+ common/autoconf/flags.m4               | 14 +++++++---
+ common/autoconf/platform.m4            | 38 ++++++++++++++++++++++++--
+ common/autoconf/spec.gmk.in            |  4 +++
+ 5 files changed, 66 insertions(+), 6 deletions(-)
+
+diff --git a/common/autoconf/build-aux/config.guess b/common/autoconf/build-aux/config.guess
+index 355c91e4eb..5494ba2546 100644
+--- a/common/autoconf/build-aux/config.guess
++++ b/common/autoconf/build-aux/config.guess
+@@ -30,6 +30,17 @@
+ DIR=`dirname $0`
+ OUT=`. $DIR/autoconf-config.guess`
+ 
++# Detect C library.
++# Use '-gnu'  suffix on systems that use glibc.
++# Use '-musl' suffix on systems that use the musl libc.
++echo $OUT | grep -- -linux- > /dev/null 2> /dev/null
++if test $? = 0; then
++  ldd_version=`ldd --version 2>&1 | head -1 | cut -f1 -d' '`
++  if [ x"${ldd_version}" = x"musl" ]; then
++    OUT=`echo $OUT | sed 's/-gnu/-musl/'`
++  fi
++fi
++
+ # Test and fix solaris on x86_64
+ echo $OUT | grep i386-pc-solaris > /dev/null 2> /dev/null
+ if test $? = 0; then
+diff --git a/common/autoconf/build-aux/config.sub b/common/autoconf/build-aux/config.sub
+index cc958da946..a665b00fcc 100644
+--- a/common/autoconf/build-aux/config.sub
++++ b/common/autoconf/build-aux/config.sub
+@@ -29,6 +29,11 @@
+ 
+ DIR=`dirname $0`
+ 
++if echo $* | grep linux-musl >/dev/null ; then
++    echo $*
++    exit
++fi
++
+ # First, filter out everything that doesn't begin with "aarch64-"
+ if ! echo $* | grep '^aarch64-' >/dev/null ; then
+     . $DIR/autoconf-config.sub "$@"
+diff --git a/common/autoconf/flags.m4 b/common/autoconf/flags.m4
+index 73b2e76511..4cfaa83d9b 100644
+--- a/common/autoconf/flags.m4
++++ b/common/autoconf/flags.m4
+@@ -474,13 +474,19 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
+   AC_ARG_WITH(extra-asflags, [AS_HELP_STRING([--with-extra-asflags],
+       [extra flags to be passed to the assembler])])
+ 
+-  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags"
+-  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags"
++  # Define MUSL_LIBC
++  DEFINE_LIBC=""
++  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
++    DEFINE_LIBC="-DMUSL_LIBC"
++  fi
++
++  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags ${DEFINE_LIBC}"
++  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags ${DEFINE_LIBC}"
+   LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
+ 
+   # Hotspot needs these set in their legacy form
+-  LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $with_extra_cflags"
+-  LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $with_extra_cxxflags"
++  LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $with_extra_cflags $DEFINE_LIBC"
++  LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $with_extra_cxxflags $DEFINE_LIBC"
+   LEGACY_EXTRA_LDFLAGS="$LEGACY_EXTRA_LDFLAGS $with_extra_ldflags"
+   LEGACY_EXTRA_ASFLAGS="$with_extra_asflags"
+ 
+diff --git a/common/autoconf/platform.m4 b/common/autoconf/platform.m4
+index 51df988f61..a133cfc7a2 100644
+--- a/common/autoconf/platform.m4
++++ b/common/autoconf/platform.m4
+@@ -149,6 +149,24 @@ AC_DEFUN([PLATFORM_EXTRACT_VARS_FROM_OS],
+   esac
+ ])
+ 
++# Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
++# Converts autoconf style OS name to OpenJDK style, into
++# VAR_LIBC.
++AC_DEFUN([PLATFORM_EXTRACT_VARS_FROM_LIBC],
++[
++  case "$1" in
++    *linux*-musl)
++      VAR_LIBC=musl
++      ;;
++    *linux*-gnu)
++      VAR_LIBC=gnu
++      ;;
++    *)
++      VAR_LIBC=default
++      ;;
++  esac
++])
++
+ # Expects $host_os $host_cpu $build_os and $build_cpu
+ # and $with_target_bits to have been setup!
+ #
+@@ -166,9 +184,10 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
+   AC_SUBST(OPENJDK_TARGET_AUTOCONF_NAME)
+   AC_SUBST(OPENJDK_BUILD_AUTOCONF_NAME)
+ 
+-  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
++  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
+   PLATFORM_EXTRACT_VARS_FROM_OS($build_os)
+   PLATFORM_EXTRACT_VARS_FROM_CPU($build_cpu)
++  PLATFORM_EXTRACT_VARS_FROM_LIBC($build_os)
+   # ..and setup our own variables. (Do this explicitely to facilitate searching)
+   OPENJDK_BUILD_OS="$VAR_OS"
+   OPENJDK_BUILD_OS_API="$VAR_OS_API"
+@@ -177,6 +196,7 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
+   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
+   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
+   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
++  OPENJDK_BUILD_LIBC="$VAR_LIBC"
+   AC_SUBST(OPENJDK_BUILD_OS)
+   AC_SUBST(OPENJDK_BUILD_OS_API)
+   AC_SUBST(OPENJDK_BUILD_OS_ENV)
+@@ -184,13 +204,20 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
+   AC_SUBST(OPENJDK_BUILD_CPU_ARCH)
+   AC_SUBST(OPENJDK_BUILD_CPU_BITS)
+   AC_SUBST(OPENJDK_BUILD_CPU_ENDIAN)
++  AC_SUBST(OPENJDK_BUILD_LIBC)
+ 
+   AC_MSG_CHECKING([openjdk-build os-cpu])
+   AC_MSG_RESULT([$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU])
+ 
+-  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
++  if test "x$OPENJDK_BUILD_OS" = "xlinux"; then
++    AC_MSG_CHECKING([openjdk-build C library])
++    AC_MSG_RESULT([$OPENJDK_BUILD_LIBC])
++  fi
++
++  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
+   PLATFORM_EXTRACT_VARS_FROM_OS($host_os)
+   PLATFORM_EXTRACT_VARS_FROM_CPU($host_cpu)
++  PLATFORM_EXTRACT_VARS_FROM_LIBC($host_os)
+   # ... and setup our own variables. (Do this explicitely to facilitate searching)
+   OPENJDK_TARGET_OS="$VAR_OS"
+   OPENJDK_TARGET_OS_API="$VAR_OS_API"
+@@ -199,6 +226,7 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
+   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
+   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
+   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
++  OPENJDK_TARGET_LIBC="$VAR_LIBC"
+   AC_SUBST(OPENJDK_TARGET_OS)
+   AC_SUBST(OPENJDK_TARGET_OS_API)
+   AC_SUBST(OPENJDK_TARGET_OS_ENV)
+@@ -206,9 +234,15 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
+   AC_SUBST(OPENJDK_TARGET_CPU_ARCH)
+   AC_SUBST(OPENJDK_TARGET_CPU_BITS)
+   AC_SUBST(OPENJDK_TARGET_CPU_ENDIAN)
++  AC_SUBST(OPENJDK_TARGET_LIBC)
+ 
+   AC_MSG_CHECKING([openjdk-target os-cpu])
+   AC_MSG_RESULT([$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU])
++
++  if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
++    AC_MSG_CHECKING([openjdk-target C library])
++    AC_MSG_RESULT([$OPENJDK_TARGET_LIBC])
++  fi
+ ])
+ 
+ # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
+diff --git a/common/autoconf/spec.gmk.in b/common/autoconf/spec.gmk.in
+index 506cf61708..a5da573a73 100644
+--- a/common/autoconf/spec.gmk.in
++++ b/common/autoconf/spec.gmk.in
+@@ -85,6 +85,8 @@ OPENJDK_TARGET_CPU_ARCH:=@OPENJDK_TARGET_CPU_ARCH@
+ OPENJDK_TARGET_CPU_BITS:=@OPENJDK_TARGET_CPU_BITS@
+ OPENJDK_TARGET_CPU_ENDIAN:=@OPENJDK_TARGET_CPU_ENDIAN@
+ 
++OPENJDK_TARGET_LIBC:=@OPENJDK_TARGET_LIBC@
++
+ COMPILE_TYPE:=@COMPILE_TYPE@
+ 
+ # Legacy support
+@@ -108,6 +110,8 @@ OPENJDK_BUILD_CPU_ARCH:=@OPENJDK_BUILD_CPU_ARCH@
+ OPENJDK_BUILD_CPU_BITS:=@OPENJDK_BUILD_CPU_BITS@
+ OPENJDK_BUILD_CPU_ENDIAN:=@OPENJDK_BUILD_CPU_ENDIAN@
+ 
++OPENJDK_BUILD_LIBC:=@OPENJDK_BUILD_LIBC@
++
+ # Legacy OS values for use in release file.
+ REQUIRED_OS_NAME:=@REQUIRED_OS_NAME@
+ REQUIRED_OS_VERSION:=@REQUIRED_OS_VERSION@
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0006-Change-glibc_version-to-libc_version.patch b/patches/alpine-jdk8u/0006-Change-glibc_version-to-libc_version.patch
new file mode 100644
index 0000000..6851a51
--- /dev/null
+++ b/patches/alpine-jdk8u/0006-Change-glibc_version-to-libc_version.patch
@@ -0,0 +1,143 @@
+From 32eabea07e0fbb17c43ac4fc5603c920f877df88 Mon Sep 17 00:00:00 2001
+From: Stephanie Crater <scrater@microsoft.com>
+Date: Mon, 7 Mar 2022 16:58:38 -0800
+Subject: [PATCH] Change glibc_version to libc_version
+
+---
+ hotspot/src/os/linux/vm/os_linux.cpp | 27 ++++++++++++++++++++-------
+ hotspot/src/os/linux/vm/os_linux.hpp |  6 +++---
+ 2 files changed, 23 insertions(+), 10 deletions(-)
+
+diff --git a/hotspot/src/os/linux/vm/os_linux.cpp b/hotspot/src/os/linux/vm/os_linux.cpp
+index 2d3880b363..156d0eef43 100644
+--- a/hotspot/src/os/linux/vm/os_linux.cpp
++++ b/hotspot/src/os/linux/vm/os_linux.cpp
+@@ -95,7 +95,6 @@
+ # include <string.h>
+ # include <syscall.h>
+ # include <sys/sysinfo.h>
+-# include <gnu/libc-version.h>
+ # include <sys/ipc.h>
+ # include <sys/shm.h>
+ # include <link.h>
+@@ -103,6 +102,10 @@
+ # include <inttypes.h>
+ # include <sys/ioctl.h>
+ 
++#ifndef MUSL_LIBC
++#include <gnu/libc-version.h>
++#endif
++
+ PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
+ 
+ #ifndef _GNU_SOURCE
+@@ -144,7 +147,7 @@ const int os::Linux::_vm_default_page_size = (8 * K);
+ bool os::Linux::_is_floating_stack = false;
+ bool os::Linux::_is_NPTL = false;
+ bool os::Linux::_supports_fast_thread_cpu_time = false;
+-const char * os::Linux::_glibc_version = NULL;
++const char * os::Linux::_libc_version = NULL;
+ const char * os::Linux::_libpthread_version = NULL;
+ pthread_condattr_t os::Linux::_condattr[1];
+ 
+@@ -581,6 +584,15 @@ void os::Linux::hotspot_sigmask(Thread* thread) {
+ // detecting pthread library
+ 
+ void os::Linux::libpthread_init() {
++#ifdef MUSL_LIBC
++  // Hard code Alpine Linux supported musl compatible settings.
++  // confstr() from musl libc returns EINVAL for
++  // _CS_GNU_LIBC_VERSION and _CS_GNU_LIBPTHREAD_VERSION
++  os::Linux::set_libc_version("musl - unknown");
++  os::Linux::set_libpthread_version("musl - unknown");
++  os::Linux::set_is_NPTL();
++  os::Linux::set_is_floating_stack();
++#else
+   // Save glibc and pthread version strings. Note that _CS_GNU_LIBC_VERSION
+   // and _CS_GNU_LIBPTHREAD_VERSION are supported in glibc >= 2.3.2. Use a
+   // generic name for earlier versions.
+@@ -596,13 +608,13 @@ void os::Linux::libpthread_init() {
+   if (n > 0) {
+      char *str = (char *)malloc(n, mtInternal);
+      confstr(_CS_GNU_LIBC_VERSION, str, n);
+-     os::Linux::set_glibc_version(str);
++     os::Linux::set_libc_version(str);
+   } else {
+      // _CS_GNU_LIBC_VERSION is not supported, try gnu_get_libc_version()
+      static char _gnu_libc_version[32];
+      jio_snprintf(_gnu_libc_version, sizeof(_gnu_libc_version),
+               "glibc %s %s", gnu_get_libc_version(), gnu_get_libc_release());
+-     os::Linux::set_glibc_version(_gnu_libc_version);
++     os::Linux::set_libc_version(_gnu_libc_version);
+   }
+ 
+   n = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, 0);
+@@ -615,7 +627,7 @@ void os::Linux::libpthread_init() {
+      // So sysconf(_SC_THREAD_THREADS_MAX) will return a positive value.
+      // On the other hand, NPTL does not have such a limit, sysconf()
+      // will return -1 and errno is not changed. Check if it is really NPTL.
+-     if (strcmp(os::Linux::glibc_version(), "glibc 2.3.2") == 0 &&
++     if (strcmp(os::Linux::libc_version(), "glibc 2.3.2") == 0 &&
+          strstr(str, "NPTL") &&
+          sysconf(_SC_THREAD_THREADS_MAX) > 0) {
+        free(str);
+@@ -639,6 +651,7 @@ void os::Linux::libpthread_init() {
+   if (os::Linux::is_NPTL() || os::Linux::supports_variable_stack_size()) {
+      os::Linux::set_is_floating_stack();
+   }
++#endif
+ }
+ 
+ /////////////////////////////////////////////////////////////////////////////
+@@ -2269,7 +2282,7 @@ void os::Linux::print_distro_info(outputStream* st) {
+ void os::Linux::print_libversion_info(outputStream* st) {
+   // libc, pthread
+   st->print("libc:");
+-  st->print("%s ", os::Linux::glibc_version());
++  st->print("%s ", os::Linux::libc_version());
+   st->print("%s ", os::Linux::libpthread_version());
+   if (os::Linux::is_LinuxThreads()) {
+      st->print("(%s stack)", os::Linux::is_floating_stack() ? "floating" : "fixed");
+@@ -5186,7 +5199,7 @@ jint os::init_2(void)
+   Linux::libpthread_init();
+   if (PrintMiscellaneous && (Verbose || WizardMode)) {
+      tty->print_cr("[HotSpot is running with %s, %s(%s)]\n",
+-          Linux::glibc_version(), Linux::libpthread_version(),
++          Linux::libc_version(), Linux::libpthread_version(),
+           Linux::is_floating_stack() ? "floating stack" : "fixed stack");
+   }
+ 
+diff --git a/hotspot/src/os/linux/vm/os_linux.hpp b/hotspot/src/os/linux/vm/os_linux.hpp
+index 79a9f39ab7..649caba76f 100644
+--- a/hotspot/src/os/linux/vm/os_linux.hpp
++++ b/hotspot/src/os/linux/vm/os_linux.hpp
+@@ -61,7 +61,7 @@ class Linux {
+   static address   _initial_thread_stack_bottom;
+   static uintptr_t _initial_thread_stack_size;
+ 
+-  static const char *_glibc_version;
++  static const char *_libc_version;
+   static const char *_libpthread_version;
+ 
+   static bool _is_floating_stack;
+@@ -90,7 +90,7 @@ class Linux {
+   static int commit_memory_impl(char* addr, size_t bytes,
+                                 size_t alignment_hint, bool exec);
+ 
+-  static void set_glibc_version(const char *s)      { _glibc_version = s; }
++  static void set_libc_version(const char *s)       { _libc_version = s; }
+   static void set_libpthread_version(const char *s) { _libpthread_version = s; }
+ 
+   static bool supports_variable_stack_size();
+@@ -181,7 +181,7 @@ class Linux {
+   static bool chained_handler(int sig, siginfo_t* siginfo, void* context);
+ 
+   // GNU libc and libpthread version strings
+-  static const char *glibc_version()          { return _glibc_version; }
++  static const char *libc_version()           { return _libc_version; }
+   static const char *libpthread_version()     { return _libpthread_version; }
+ 
+   // NPTL or LinuxThreads?
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0007-Don-t-build-SA-if-using-musl-libc.patch b/patches/alpine-jdk8u/0007-Don-t-build-SA-if-using-musl-libc.patch
new file mode 100644
index 0000000..c44ed5d
--- /dev/null
+++ b/patches/alpine-jdk8u/0007-Don-t-build-SA-if-using-musl-libc.patch
@@ -0,0 +1,92 @@
+From 5f57a1ed5a9dc6af40663cfe923ce98792d29546 Mon Sep 17 00:00:00 2001
+From: Stephanie Crater <scrater@microsoft.com>
+Date: Mon, 7 Mar 2022 17:21:52 -0800
+Subject: [PATCH] Don't build SA if using musl libc
+
+---
+ common/autoconf/jdk-options.m4           | 3 +++
+ hotspot/make/linux/makefiles/defs.make   | 8 ++++++++
+ hotspot/make/linux/makefiles/sa.make     | 4 +++-
+ hotspot/make/linux/makefiles/saproc.make | 3 +++
+ 4 files changed, 17 insertions(+), 1 deletion(-)
+
+diff --git a/common/autoconf/jdk-options.m4 b/common/autoconf/jdk-options.m4
+index 42aeb7bd61..e46cb823ef 100644
+--- a/common/autoconf/jdk-options.m4
++++ b/common/autoconf/jdk-options.m4
+@@ -152,6 +152,9 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_JVM_VARIANTS],
+   AC_SUBST(JVM_VARIANT_CORE)
+ 
+   INCLUDE_SA=true
++  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
++    INCLUDE_SA=false
++  fi
+   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
+     INCLUDE_SA=false
+   fi
+diff --git a/hotspot/make/linux/makefiles/defs.make b/hotspot/make/linux/makefiles/defs.make
+index ec414639d2..5d05825300 100644
+--- a/hotspot/make/linux/makefiles/defs.make
++++ b/hotspot/make/linux/makefiles/defs.make
+@@ -305,6 +305,9 @@ endif
+ 
+ # Serviceability Binaries
+ # No SA Support for PPC, IA64, ARM or zero
++# or if thread_db.h missing (musl)
++
++ifneq ($(wildcard /usr/include/thread_db.h),)
+ ADD_SA_BINARIES/x86   = $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.$(LIBRARY_SUFFIX) \
+                         $(EXPORT_LIB_DIR)/sa-jdi.jar
+ ADD_SA_BINARIES/sparc = $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.$(LIBRARY_SUFFIX) \
+@@ -324,6 +327,11 @@ ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
+     endif
+   endif
+ endif
++else
++ADD_SA_BINARIES/x86     =
++ADD_SA_BINARIES/sparc   =
++ADD_SA_BINARIES/aarch64 =
++endif
+ ADD_SA_BINARIES/ppc   =
+ ADD_SA_BINARIES/ia64  =
+ ADD_SA_BINARIES/arm   =
+diff --git a/hotspot/make/linux/makefiles/sa.make b/hotspot/make/linux/makefiles/sa.make
+index cdcb16a1a3..5c2f661ee1 100644
+--- a/hotspot/make/linux/makefiles/sa.make
++++ b/hotspot/make/linux/makefiles/sa.make
+@@ -59,9 +59,11 @@ SA_PROPERTIES = $(SA_CLASSDIR)/sa.properties
+ 
+ # if $(AGENT_DIR) does not exist, we don't build SA
+ # also, we don't build SA on Itanium or zero.
++# check for thread_db.h too (musl does not have it).
+ 
+ all: 
+-	if [ -d $(AGENT_DIR) -a "$(SRCARCH)" != "ia64" \
++if [ -d $(AGENT_DIR) -a -f /usr/include/thread_db.h \
++             -a "$(SRCARCH)" != "ia64" \
+              -a "$(SRCARCH)" != "zero" ] ; then \
+ 	   $(MAKE) -f sa.make $(GENERATED)/sa-jdi.jar; \
+ 	fi
+diff --git a/hotspot/make/linux/makefiles/saproc.make b/hotspot/make/linux/makefiles/saproc.make
+index ffc0ec5ce5..732c7614d6 100644
+--- a/hotspot/make/linux/makefiles/saproc.make
++++ b/hotspot/make/linux/makefiles/saproc.make
+@@ -66,12 +66,15 @@ endif
+ 
+ # if $(AGENT_DIR) does not exist, we don't build SA
+ # also, we don't build SA on Itanium or zero.
++# check for thread_db.h too (musl does not have it).
+ 
++ifneq ($(wildcard /usr/include/thread_db.h),)
+ ifneq ($(wildcard $(AGENT_DIR)),)
+ ifneq ($(filter-out ia64 zero,$(SRCARCH)),)
+   BUILDLIBSAPROC = $(LIBSAPROC)
+ endif
+ endif
++endif
+ 
+ ifneq ($(ALT_SASRCDIR),)
+ ALT_SAINCDIR=-I$(ALT_SASRCDIR) -DALT_SASRCDIR
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0008-Apply-Alpine-s-patches-for-musl-libc.patch b/patches/alpine-jdk8u/0008-Apply-Alpine-s-patches-for-musl-libc.patch
new file mode 100644
index 0000000..4a22e3a
--- /dev/null
+++ b/patches/alpine-jdk8u/0008-Apply-Alpine-s-patches-for-musl-libc.patch
@@ -0,0 +1,360 @@
+From 8937a62908a651a24d41a9bf46fc2928cbb0f71b Mon Sep 17 00:00:00 2001
+From: Stephanie Crater <scrater@microsoft.com>
+Date: Mon, 7 Mar 2022 16:46:47 -0800
+Subject: [PATCH] Apply Alpine's patches for musl libc
+
+---
+ hotspot/src/os/linux/vm/jvm_linux.cpp         |  2 +
+ hotspot/src/os/linux/vm/os_linux.cpp          | 13 ++++-
+ .../linux_aarch64/vm/os_linux_aarch64.cpp     |  7 ++-
+ .../src/os_cpu/linux_x86/vm/os_linux_x86.cpp  | 10 +++-
+ .../linux_x86/vm/threadLS_linux_x86.hpp       |  2 +
+ .../vm/utilities/globalDefinitions_gcc.hpp    |  2 +-
+ jdk/src/solaris/bin/java_md_solinux.c         |  4 ++
+ .../solaris/native/java/lang/UNIXProcess_md.c |  8 +++
+ jdk/src/solaris/native/java/lang/childproc.c  | 57 ++++++++++++++++++-
+ .../native/java/net/Inet4AddressImpl.c        |  2 +-
+ jdk/src/solaris/native/java/net/net_util_md.c | 12 ++--
+ .../sun/tools/attach/LinuxVirtualMachine.c    |  4 ++
+ 12 files changed, 111 insertions(+), 12 deletions(-)
+
+diff --git a/hotspot/src/os/linux/vm/jvm_linux.cpp b/hotspot/src/os/linux/vm/jvm_linux.cpp
+index ba84788a1b..c22281f7ca 100644
+--- a/hotspot/src/os/linux/vm/jvm_linux.cpp
++++ b/hotspot/src/os/linux/vm/jvm_linux.cpp
+@@ -154,7 +154,9 @@ struct siglabel siglabels[] = {
+ #ifdef SIGSTKFLT
+   "STKFLT",     SIGSTKFLT,      /* Stack fault.  */
+ #endif
++#ifdef SIGCLD
+   "CLD",        SIGCLD,         /* Same as SIGCHLD (System V).  */
++#endif
+   "CHLD",       SIGCHLD,        /* Child status has changed (POSIX).  */
+   "CONT",       SIGCONT,        /* Continue (POSIX).  */
+   "STOP",       SIGSTOP,        /* Stop, unblockable (POSIX).  */
+diff --git a/hotspot/src/os/linux/vm/os_linux.cpp b/hotspot/src/os/linux/vm/os_linux.cpp
+index 156d0eef43..88a06ffc06 100644
+--- a/hotspot/src/os/linux/vm/os_linux.cpp
++++ b/hotspot/src/os/linux/vm/os_linux.cpp
+@@ -809,7 +809,7 @@ static void *java_start(Thread *thread) {
+   // processors with hyperthreading technology.
+   static int counter = 0;
+   int pid = os::current_process_id();
+-  alloca(((pid ^ counter++) & 7) * 128);
++  void *tmp = alloca(((pid ^ counter++) & 7) * 128);
+ 
+   ThreadLocalStorage::set_thread(thread);
+ 
+@@ -2987,6 +2987,14 @@ extern "C" JNIEXPORT void numa_warn(int number, char *where, ...) { }
+ extern "C" JNIEXPORT void numa_error(char *where) { }
+ extern "C" JNIEXPORT int fork1() { return fork(); }
+ 
++#ifdef MUSL_LIBC
++  // dlvsym is not a part of POSIX and musl libc doesn't implement it.
++  static void *dlvsym(void *handle, const char *name, const char *ver)
++  {
++    return dlsym(handle, name);
++  }
++#endif
++
+ // Handle request to load libnuma symbol version 1.1 (API v1). If it fails
+ // load symbol from base version instead.
+ void* os::Linux::libnuma_dlsym(void* handle, const char *name) {
+@@ -5009,7 +5017,8 @@ void os::Linux::check_signal_handler(int sig) {
+   }
+ 
+   if (thisHandler != jvmHandler) {
+-    tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
++    if(exception_name(sig, buf, O_BUFLEN))
++      tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
+     tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN));
+     tty->print_cr("  found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN));
+     // No need to check this sig any longer
+diff --git a/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp b/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
+index 82e36d27f8..cf476a0b27 100644
+--- a/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
++++ b/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
+@@ -72,7 +72,12 @@
+ # include <pwd.h>
+ # include <poll.h>
+ # include <ucontext.h>
+-# include <fpu_control.h>
++
++#ifdef MUSL_LIBC
++#include <fpu_control.h>
++#else
++#include <linux/types.h>  /* provides __u64 */
++#endif
+ 
+ #define REG_FP 29
+ 
+diff --git a/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp b/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp
+index 65c3165ca1..5505e573ff 100644
+--- a/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp
++++ b/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp
+@@ -72,7 +72,10 @@
+ # include <pwd.h>
+ # include <poll.h>
+ # include <ucontext.h>
+-# include <fpu_control.h>
++
++#ifndef MUSL_LIBC
++#include <fpu_control.h>
++#endif
+ 
+ #ifdef AMD64
+ #define REG_SP REG_RSP
+@@ -544,6 +547,11 @@ JVM_handle_linux_signal(int sig,
+   return true; // Mute compiler
+ }
+ 
++#ifdef MUSL_LIBC
++#define _FPU_GETCW(cw) __asm__ __volatile__ ("fnstcw %0" : "=m" (*&cw))
++#define _FPU_SETCW(cw) __asm__ __volatile__ ("fldcw %0" : : "m" (*&cw))
++#endif
++
+ void os::Linux::init_thread_fpu_state(void) {
+ #ifndef AMD64
+   // set fpu to 53 bit precision
+diff --git a/hotspot/src/os_cpu/linux_x86/vm/threadLS_linux_x86.hpp b/hotspot/src/os_cpu/linux_x86/vm/threadLS_linux_x86.hpp
+index f3f2f26f88..00b472693a 100644
+--- a/hotspot/src/os_cpu/linux_x86/vm/threadLS_linux_x86.hpp
++++ b/hotspot/src/os_cpu/linux_x86/vm/threadLS_linux_x86.hpp
+@@ -32,7 +32,9 @@
+   // map stack pointer to thread pointer - see notes in threadLS_linux_x86.cpp
+   #define SP_BITLENGTH  32
+   #define PAGE_SHIFT    12
++  #if !defined(MUSL_LIBC) || !defined(PAGE_SIZE)
+   #define PAGE_SIZE     (1UL << PAGE_SHIFT)
++  #endif
+   static Thread* _sp_map[1UL << (SP_BITLENGTH - PAGE_SHIFT)];
+ 
+ public:
+diff --git a/hotspot/src/share/vm/utilities/globalDefinitions_gcc.hpp b/hotspot/src/share/vm/utilities/globalDefinitions_gcc.hpp
+index 5760eb2fab..be1e4dbce0 100644
+--- a/hotspot/src/share/vm/utilities/globalDefinitions_gcc.hpp
++++ b/hotspot/src/share/vm/utilities/globalDefinitions_gcc.hpp
+@@ -235,7 +235,7 @@ inline int g_isnan(double f) { return isnand(f); }
+ #elif defined(__APPLE__)
+ inline int g_isnan(double f) { return isnan(f); }
+ #elif defined(LINUX) || defined(_ALLBSD_SOURCE)
+-inline int g_isnan(float  f) { return isnanf(f); }
++inline int g_isnan(float  f) { return isnan(f); }
+ inline int g_isnan(double f) { return isnan(f); }
+ #else
+ #error "missing platform-specific definition here"
+diff --git a/jdk/src/solaris/bin/java_md_solinux.c b/jdk/src/solaris/bin/java_md_solinux.c
+index a96713757d..162b50073b 100644
+--- a/jdk/src/solaris/bin/java_md_solinux.c
++++ b/jdk/src/solaris/bin/java_md_solinux.c
+@@ -292,6 +292,10 @@ RequiresSetenv(int wanted, const char *jvmpath) {
+     char *dmllp = NULL;
+     char *p; /* a utility pointer */
+ 
++#ifdef MUSL_LIBC
++    return JNI_TRUE;
++#endif
++
+ #ifdef AIX
+     /* We always have to set the LIBPATH on AIX because ld doesn't support $ORIGIN. */
+     return JNI_TRUE;
+diff --git a/jdk/src/solaris/native/java/lang/UNIXProcess_md.c b/jdk/src/solaris/native/java/lang/UNIXProcess_md.c
+index 9b510ad3a9..ad233a2a76 100644
+--- a/jdk/src/solaris/native/java/lang/UNIXProcess_md.c
++++ b/jdk/src/solaris/native/java/lang/UNIXProcess_md.c
+@@ -550,7 +550,11 @@ static pid_t
+ startChild(JNIEnv *env, jobject process, ChildStuff *c, const char *helperpath) {
+     switch (c->mode) {
+       case MODE_VFORK:
++// use regular fork when running on musl
++// this should fix deadlocks on aarch64
++#ifndef MUSL_LIBC
+         return vforkChild(c);
++#endif
+       case MODE_FORK:
+         return forkChild(c);
+ #if defined(__solaris__) || defined(_ALLBSD_SOURCE) || defined(_AIX)
+@@ -649,8 +653,12 @@ Java_java_lang_UNIXProcess_forkAndExec(JNIEnv *env,
+     if (resultPid < 0) {
+         switch (c->mode) {
+           case MODE_VFORK:
++// use regular fork when running on musl
++// this should fix deadlocks on aarch64
++#ifndef MUSL_LIBC
+             throwIOException(env, errno, "vfork failed");
+             break;
++#endif
+           case MODE_FORK:
+             throwIOException(env, errno, "fork failed");
+             break;
+diff --git a/jdk/src/solaris/native/java/lang/childproc.c b/jdk/src/solaris/native/java/lang/childproc.c
+index c0045d5371..2d20db6185 100644
+--- a/jdk/src/solaris/native/java/lang/childproc.c
++++ b/jdk/src/solaris/native/java/lang/childproc.c
+@@ -23,7 +23,6 @@
+  * questions.
+  */
+ 
+-#include <dirent.h>
+ #include <errno.h>
+ #include <fcntl.h>
+ #include <stdlib.h>
+@@ -31,6 +30,12 @@
+ #include <unistd.h>
+ #include <limits.h>
+ 
++#ifndef MUSL_LIBC
++#include <dirent.h>
++#else
++#include <poll.h>
++#endif
++
+ #include "childproc.h"
+ 
+ const char * const *parentPathv;
+@@ -57,6 +62,8 @@ closeSafely(int fd)
+     return (fd == -1) ? 0 : close(fd);
+ }
+ 
++#ifndef MUSL_LIBC
++
+ int
+ isAsciiDigit(char c)
+ {
+@@ -115,6 +122,54 @@ closeDescriptors(void)
+     return 1;
+ }
+ 
++#else // Musl
++
++int
++closeDescriptors(void)
++{
++    int from_fd = FAIL_FILENO + 1;
++    struct pollfd pfds[1024];
++    int i, total, nclosed = 0;
++    int max_fd = sysconf(_SC_OPEN_MAX);
++
++    if (max_fd < 0)
++        return 0;
++
++    /* init events */
++    total = max_fd - from_fd;
++    for (i = 0; i < (total < 1024 ? total : 1024); i++) {
++        pfds[i].events = 0;
++    }
++
++    while (from_fd < max_fd) {
++        int nfds, r = 0;
++
++        total = max_fd - from_fd;
++        nfds =  total < 1024 ? total : 1024;
++
++        for (i = 0; i < nfds; i++)
++            pfds[i].fd = from_fd + i;
++
++        do {
++            r = poll(pfds, nfds, 0);
++        } while (r == -1 && errno == EINTR);
++
++        if (r < 0)
++            return 0;
++
++
++        for (i = 0; i < nfds; i++)
++            if (pfds[i].revents != POLLNVAL) {
++                nclosed++;
++                close(pfds[i].fd);
++            }
++        from_fd += nfds;
++    }
++    return 1;
++}
++
++#endif
++
+ int
+ moveDescriptor(int fd_from, int fd_to)
+ {
+diff --git a/jdk/src/solaris/native/java/net/Inet4AddressImpl.c b/jdk/src/solaris/native/java/net/Inet4AddressImpl.c
+index 7e193a9319..dba1fa689e 100644
+--- a/jdk/src/solaris/native/java/net/Inet4AddressImpl.c
++++ b/jdk/src/solaris/native/java/net/Inet4AddressImpl.c
+@@ -47,7 +47,7 @@
+ 
+ #include "java_net_Inet4AddressImpl.h"
+ 
+-#if defined(__GLIBC__) || (defined(__FreeBSD__) && (__FreeBSD_version >= 601104))
++#if defined(__linux__) || (defined(__FreeBSD__) && (__FreeBSD_version >= 601104))
+ #define HAS_GLIBC_GETHOSTBY_R   1
+ #endif
+ 
+diff --git a/jdk/src/solaris/native/java/net/net_util_md.c b/jdk/src/solaris/native/java/net/net_util_md.c
+index bd0bd8c2c9..4c021aea4d 100644
+--- a/jdk/src/solaris/native/java/net/net_util_md.c
++++ b/jdk/src/solaris/native/java/net/net_util_md.c
+@@ -662,7 +662,7 @@ struct localinterface {
+ 
+ static struct localinterface *localifs = 0;
+ static int localifsSize = 0;    /* size of array */
+-static int nifs = 0;            /* number of entries used in array */
++static int nifs = -1; /* number of entries used in array */
+ 
+ /* not thread safe: make sure called once from one thread */
+ 
+@@ -674,6 +674,10 @@ static void initLocalIfs () {
+     int index, x1, x2, x3;
+     unsigned int u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,ua,ub,uc,ud,ue,uf;
+ 
++    if (nifs >= 0)
++	    return ;
++    nifs = 0;
++
+     if ((f = fopen("/proc/net/if_inet6", "r")) == NULL) {
+         return ;
+     }
+@@ -702,7 +706,7 @@ static void initLocalIfs () {
+             localifs = (struct localinterface *) realloc (
+                         localifs, sizeof (struct localinterface)* (localifsSize+5));
+             if (localifs == 0) {
+-                nifs = 0;
++                nifs = -1;
+                 fclose (f);
+                 return;
+             }
+@@ -725,9 +729,7 @@ static void initLocalIfs () {
+ static int getLocalScopeID (char *addr) {
+     struct localinterface *lif;
+     int i;
+-    if (localifs == 0) {
+-        initLocalIfs();
+-    }
++    initLocalIfs();
+     for (i=0, lif=localifs; i<nifs; i++, lif++) {
+         if (memcmp (addr, lif->localaddr, 16) == 0) {
+             return lif->index;
+diff --git a/jdk/src/solaris/native/sun/tools/attach/LinuxVirtualMachine.c b/jdk/src/solaris/native/sun/tools/attach/LinuxVirtualMachine.c
+index 6017308d0b..a583b4bae8 100644
+--- a/jdk/src/solaris/native/sun/tools/attach/LinuxVirtualMachine.c
++++ b/jdk/src/solaris/native/sun/tools/attach/LinuxVirtualMachine.c
+@@ -195,6 +195,9 @@ JNIEXPORT void JNICALL Java_sun_tools_attach_LinuxVirtualMachine_connect
+ JNIEXPORT jboolean JNICALL Java_sun_tools_attach_LinuxVirtualMachine_isLinuxThreads
+   (JNIEnv *env, jclass cls)
+ {
++# ifdef MUSL_LIBC
++   return JNI_FALSE;
++# else
+ # ifndef _CS_GNU_LIBPTHREAD_VERSION
+ # define _CS_GNU_LIBPTHREAD_VERSION 3
+ # endif
+@@ -222,6 +225,7 @@ JNIEXPORT jboolean JNICALL Java_sun_tools_attach_LinuxVirtualMachine_isLinuxThre
+     res = (jboolean)(strstr(s, "NPTL") == NULL);
+     free(s);
+     return res;
++# endif
+ }
+ 
+ /*
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0009-Apply-Alpine-s-ppc-patch-for-musl-libc.patch b/patches/alpine-jdk8u/0009-Apply-Alpine-s-ppc-patch-for-musl-libc.patch
new file mode 100644
index 0000000..add2b57
--- /dev/null
+++ b/patches/alpine-jdk8u/0009-Apply-Alpine-s-ppc-patch-for-musl-libc.patch
@@ -0,0 +1,236 @@
+From 1f5e05f38838733d576937108782cc3296bf7e10 Mon Sep 17 00:00:00 2001
+From: Stephanie Crater <scrater@microsoft.com>
+Date: Mon, 7 Mar 2022 16:12:23 -0800
+Subject: [PATCH] Apply Alpine's ppc patch for musl libc
+
+---
+ hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp | 22 ++++++++++
+ .../src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp  | 42 +++++++++++++++++++
+ .../os_cpu/linux_ppc/vm/thread_linux_ppc.cpp  | 13 ++++++
+ 3 files changed, 77 insertions(+)
+
+diff --git a/hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp b/hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp
+index f661847b66..d40548f680 100644
+--- a/hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp
++++ b/hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp
+@@ -1243,7 +1243,11 @@ bool MacroAssembler::is_load_from_polling_page(int instruction, void* ucontext,
+   // the safepoing polling page.
+   ucontext_t* uc = (ucontext_t*) ucontext;
+   // Set polling address.
++#ifndef MUSL_LIBC
+   address addr = (address)uc->uc_mcontext.regs->gpr[ra] + (ssize_t)ds;
++#else
++  address addr = (address)uc->uc_mcontext.gp_regs[ra] + (ssize_t)ds;
++#endif
+   if (polling_address_ptr != NULL) {
+     *polling_address_ptr = addr;
+   }
+@@ -1264,15 +1268,24 @@ bool MacroAssembler::is_memory_serialization(int instruction, JavaThread* thread
+     int rb = inv_rb_field(instruction);
+ 
+     // look up content of ra and rb in ucontext
++#ifndef MUSL_LIBC
+     address ra_val=(address)uc->uc_mcontext.regs->gpr[ra];
+     long rb_val=(long)uc->uc_mcontext.regs->gpr[rb];
++#else
++    address ra_val=(address)uc->uc_mcontext.gp_regs[ra];
++    long rb_val=(long)uc->uc_mcontext.gp_regs[rb];
++#endif
+     return os::is_memory_serialize_page(thread, ra_val+rb_val);
+   } else if (is_stw(instruction) || is_stwu(instruction)) {
+     int ra = inv_ra_field(instruction);
+     int d1 = inv_d1_field(instruction);
+ 
+     // look up content of ra in ucontext
++#ifndef MUSL_LIBC
+     address ra_val=(address)uc->uc_mcontext.regs->gpr[ra];
++#else
++    address ra_val=(address)uc->uc_mcontext.gp_regs[ra];
++#endif
+     return os::is_memory_serialize_page(thread, ra_val+d1);
+   } else {
+     return false;
+@@ -1335,11 +1348,20 @@ address MacroAssembler::get_stack_bang_address(int instruction, void *ucontext)
+       || (is_stdu(instruction) && rs == 1)) {
+     int ds = inv_ds_field(instruction);
+     // return banged address
++#ifndef MUSL_LIBC
+     return ds+(address)uc->uc_mcontext.regs->gpr[ra];
++#else
++    return ds+(address)uc->uc_mcontext.gp_regs[ra];
++#endif
+   } else if (is_stdux(instruction) && rs == 1) {
+     int rb = inv_rb_field(instruction);
++#ifndef MUSL_LIBC
+     address sp = (address)uc->uc_mcontext.regs->gpr[1];
+     long rb_val = (long)uc->uc_mcontext.regs->gpr[rb];
++#else
++    address sp = (address)uc->uc_mcontext.gp_regs[1];
++    long rb_val = (long)uc->uc_mcontext.gp_regs[rb];
++#endif
+     return ra != 1 || rb_val >= 0 ? NULL         // not a stack bang
+                                   : sp + rb_val; // banged address
+   }
+diff --git a/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp b/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp
+index 1fb993ec19..5ac8757a1f 100644
+--- a/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp
++++ b/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp
+@@ -75,6 +75,9 @@
+ # include <poll.h>
+ # include <ucontext.h>
+ 
++#ifdef MUSL_LIBC
++#include <asm/ptrace.h>
++#endif
+ 
+ address os::current_stack_pointer() {
+   intptr_t* csp;
+@@ -110,11 +113,19 @@ address os::Linux::ucontext_get_pc(ucontext_t * uc) {
+   //   it because the volatile registers are not needed to make setcontext() work.
+   //   Hopefully it was zero'd out beforehand.
+   guarantee(uc->uc_mcontext.regs != NULL, "only use ucontext_get_pc in sigaction context");
++#ifndef MUSL_LIBC
+   return (address)uc->uc_mcontext.regs->nip;
++#else
++  return (address)uc->uc_mcontext.gp_regs[PT_NIP];
++#endif
+ }
+ 
+ intptr_t* os::Linux::ucontext_get_sp(ucontext_t * uc) {
++#ifndef MUSL_LIBC
+   return (intptr_t*)uc->uc_mcontext.regs->gpr[1/*REG_SP*/];
++#else
++  return (intptr_t*)uc->uc_mcontext.gp_regs[1/*REG_SP*/];
++#endif
+ }
+ 
+ intptr_t* os::Linux::ucontext_get_fp(ucontext_t * uc) {
+@@ -217,7 +228,11 @@ JVM_handle_linux_signal(int sig,
+   if (uc) {
+     address const pc = os::Linux::ucontext_get_pc(uc);
+     if (pc && StubRoutines::is_safefetch_fault(pc)) {
++#ifndef MUSL_LIBC
+       uc->uc_mcontext.regs->nip = (unsigned long)StubRoutines::continuation_for_safefetch_fault(pc);
++#else
++      uc->uc_mcontext.gp_regs[PT_NIP] = (unsigned long)StubRoutines::continuation_for_safefetch_fault(pc);
++#endif
+       return true;
+     }
+   }
+@@ -368,7 +383,11 @@ JVM_handle_linux_signal(int sig,
+           // continue at the next instruction after the faulting read. Returning
+           // garbage from this read is ok.
+           thread->set_pending_unsafe_access_error();
++#ifndef MUSL_LIBC
+           uc->uc_mcontext.regs->nip = ((unsigned long)pc) + 4;
++#else
++          uc->uc_mcontext.gp_regs[PT_NIP] = ((unsigned long)pc) + 4;
++#endif
+           return true;
+         }
+       }
+@@ -387,7 +406,11 @@ JVM_handle_linux_signal(int sig,
+         // continue at the next instruction after the faulting read. Returning
+         // garbage from this read is ok.
+         thread->set_pending_unsafe_access_error();
++#ifndef MUSL_LIBC
+         uc->uc_mcontext.regs->nip = ((unsigned long)pc) + 4;
++#else
++        uc->uc_mcontext.gp_regs[PT_NIP] = ((unsigned long)pc) + 4;
++#endif
+         return true;
+       }
+     }
+@@ -410,7 +433,11 @@ JVM_handle_linux_signal(int sig,
+   if (stub != NULL) {
+     // Save all thread context in case we need to restore it.
+     if (thread != NULL) thread->set_saved_exception_pc(pc);
++#ifndef MUSL_LIBC
+     uc->uc_mcontext.regs->nip = (unsigned long)stub;
++#else
++    uc->uc_mcontext.gp_regs[PT_NIP] = (unsigned long)stub;
++#endif
+     return true;
+   }
+ 
+@@ -568,6 +595,7 @@ void os::print_context(outputStream *st, void *context) {
+   ucontext_t* uc = (ucontext_t*)context;
+ 
+   st->print_cr("Registers:");
++#ifndef MUSL_LIBC
+   st->print("pc =" INTPTR_FORMAT "  ", uc->uc_mcontext.regs->nip);
+   st->print("lr =" INTPTR_FORMAT "  ", uc->uc_mcontext.regs->link);
+   st->print("ctr=" INTPTR_FORMAT "  ", uc->uc_mcontext.regs->ctr);
+@@ -576,6 +604,16 @@ void os::print_context(outputStream *st, void *context) {
+     st->print("r%-2d=" INTPTR_FORMAT "  ", i, uc->uc_mcontext.regs->gpr[i]);
+     if (i % 3 == 2) st->cr();
+   }
++#else // Musl
++  st->print("pc =" INTPTR_FORMAT "  ", uc->uc_mcontext.gp_regs[PT_NIP]);
++  st->print("lr =" INTPTR_FORMAT "  ", uc->uc_mcontext.gp_regs[PT_LNK]);
++  st->print("ctr=" INTPTR_FORMAT "  ", uc->uc_mcontext.gp_regs[PT_CTR]);
++  st->cr();
++  for (int i = 0; i < 32; i++) {
++    st->print("r%-2d=" INTPTR_FORMAT "  ", i, uc->uc_mcontext.gp_regs[i]);
++    if (i % 3 == 2) st->cr();
++  }
++#endif
+   st->cr();
+   st->cr();
+ 
+@@ -604,7 +642,11 @@ void os::print_register_info(outputStream *st, void *context) {
+   // this is only for the "general purpose" registers
+   for (int i = 0; i < 32; i++) {
+     st->print("r%-2d=", i);
++#ifndef MUSL_LIBC
+     print_location(st, uc->uc_mcontext.regs->gpr[i]);
++#else
++    print_location(st, uc->uc_mcontext.gp_regs[i]);
++#endif
+   }
+   st->cr();
+ }
+diff --git a/hotspot/src/os_cpu/linux_ppc/vm/thread_linux_ppc.cpp b/hotspot/src/os_cpu/linux_ppc/vm/thread_linux_ppc.cpp
+index 802677f470..dd68a34549 100644
+--- a/hotspot/src/os_cpu/linux_ppc/vm/thread_linux_ppc.cpp
++++ b/hotspot/src/os_cpu/linux_ppc/vm/thread_linux_ppc.cpp
+@@ -27,6 +27,10 @@
+ #include "runtime/frame.inline.hpp"
+ #include "runtime/thread.hpp"
+ 
++#ifdef MUSL_LIBC
++#include <asm/ptrace.h>
++#endif
++
+ bool JavaThread::pd_get_top_frame_for_profiling(frame* fr_addr, void* ucontext, bool isInJava) {
+   assert(this->is_Java_thread(), "must be JavaThread");
+ 
+@@ -42,8 +46,13 @@ bool JavaThread::pd_get_top_frame_for_profiling(frame* fr_addr, void* ucontext,
+   // if we were running Java code when SIGPROF came in.
+   if (isInJava) {
+     ucontext_t* uc = (ucontext_t*) ucontext;
++#ifndef MUSL_LIBC
+     frame ret_frame((intptr_t*)uc->uc_mcontext.regs->gpr[1/*REG_SP*/],
+                      (address)uc->uc_mcontext.regs->nip);
++#else
++    frame ret_frame((intptr_t*)uc->uc_mcontext.gp_regs[1/*REG_SP*/],
++                     (address)uc->uc_mcontext.gp_regs[PT_NIP]);
++#endif
+ 
+     if (ret_frame.pc() == NULL) {
+       // ucontext wasn't useful
+@@ -56,7 +65,11 @@ bool JavaThread::pd_get_top_frame_for_profiling(frame* fr_addr, void* ucontext,
+       if (m == NULL || !m->is_valid_method()) return false;
+       if (!Metaspace::contains((const void*)m)) return false;
+ 
++#ifndef MUSL_LIBC
+       uint64_t reg_bcp = uc->uc_mcontext.regs->gpr[14/*R14_bcp*/];
++#else
++      uint64_t reg_bcp = uc->uc_mcontext.gp_regs[14/*R14_bcp*/];
++#endif
+       uint64_t istate_bcp = istate->bcp;
+       uint64_t code_start = (uint64_t)(m->code_base());
+       uint64_t code_end = (uint64_t)(m->code_base() + m->code_size());
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0010-Update-includes-for-musl-libc.patch b/patches/alpine-jdk8u/0010-Update-includes-for-musl-libc.patch
new file mode 100644
index 0000000..3e028d5
--- /dev/null
+++ b/patches/alpine-jdk8u/0010-Update-includes-for-musl-libc.patch
@@ -0,0 +1,317 @@
+From 7f1dda82b35e06ba752a3996ea0d5721ba5cfd52 Mon Sep 17 00:00:00 2001
+From: Stephanie Crater <scrater@microsoft.com>
+Date: Mon, 7 Mar 2022 15:26:55 -0800
+Subject: [PATCH] Update includes for musl libc
+
+---
+ hotspot/src/os/linux/vm/os_linux.inline.hpp            |  7 ++++++-
+ jdk/src/aix/native/java/net/aix_close.c                |  4 ++++
+ jdk/src/aix/native/sun/nio/ch/AixNativeThread.c        |  5 +++++
+ jdk/src/aix/native/sun/nio/ch/AixPollPort.c            |  7 ++++++-
+ jdk/src/macosx/javavm/export/jvm_md.h                  |  5 +++++
+ .../share/native/com/sun/java/util/jar/pack/zip.cpp    |  4 ++++
+ jdk/src/share/native/com/sun/java/util/jar/pack/zip.h  |  4 ++++
+ jdk/src/share/native/sun/awt/medialib/mlib_types.h     |  4 ++++
+ jdk/src/solaris/javavm/export/jvm_md.h                 |  5 +++++
+ jdk/src/solaris/native/java/net/bsd_close.c            |  5 +++++
+ jdk/src/solaris/native/java/net/linux_close.c          |  5 +++++
+ jdk/src/solaris/native/java/net/net_util_md.h          |  6 +++++-
+ .../solaris/native/sun/nio/ch/DevPollArrayWrapper.c    |  7 ++++++-
+ jdk/src/solaris/native/sun/nio/ch/Net.c                |  5 +++++
+ jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c  |  7 ++++++-
+ jdk/src/solaris/transport/socket/socket_md.c           | 10 +++++++---
+ 16 files changed, 82 insertions(+), 8 deletions(-)
+
+diff --git a/hotspot/src/os/linux/vm/os_linux.inline.hpp b/hotspot/src/os/linux/vm/os_linux.inline.hpp
+index a23bd56313..80b977711e 100644
+--- a/hotspot/src/os/linux/vm/os_linux.inline.hpp
++++ b/hotspot/src/os/linux/vm/os_linux.inline.hpp
+@@ -33,9 +33,14 @@
+ 
+ #include <unistd.h>
+ #include <sys/socket.h>
+-#include <sys/poll.h>
+ #include <netdb.h>
+ 
++#ifndef MUSL_LIBC
++#include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
++
+ inline void* os::thread_local_storage_at(int index) {
+   return pthread_getspecific((pthread_key_t)index);
+ }
+diff --git a/jdk/src/aix/native/java/net/aix_close.c b/jdk/src/aix/native/java/net/aix_close.c
+index 90d57b42f0..dfd20581ff 100644
+--- a/jdk/src/aix/native/java/net/aix_close.c
++++ b/jdk/src/aix/native/java/net/aix_close.c
+@@ -54,7 +54,11 @@
+ #include <unistd.h>
+ #include <errno.h>
+ 
++#ifndef MUSL_LIBC
+ #include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
+ 
+ /*
+  * Stack allocated by thread when doing blocking operation
+diff --git a/jdk/src/aix/native/sun/nio/ch/AixNativeThread.c b/jdk/src/aix/native/sun/nio/ch/AixNativeThread.c
+index c0d5857962..66098cc36d 100644
+--- a/jdk/src/aix/native/sun/nio/ch/AixNativeThread.c
++++ b/jdk/src/aix/native/sun/nio/ch/AixNativeThread.c
+@@ -32,7 +32,12 @@
+ #include "sun_nio_ch_NativeThread.h"
+ 
+ #include <pthread.h>
++
++#ifndef MUSL_LIBC
+ #include <sys/signal.h>
++#else
++#include <signal.h>
++#endif
+ 
+ /* Also defined in src/aix/native/java/net/aix_close.c */
+ #define INTERRUPT_SIGNAL (SIGRTMAX - 1)
+diff --git a/jdk/src/aix/native/sun/nio/ch/AixPollPort.c b/jdk/src/aix/native/sun/nio/ch/AixPollPort.c
+index 70064b890e..c0466dcc9f 100644
+--- a/jdk/src/aix/native/sun/nio/ch/AixPollPort.c
++++ b/jdk/src/aix/native/sun/nio/ch/AixPollPort.c
+@@ -34,13 +34,18 @@
+ #include <unistd.h>
+ #include <sys/types.h>
+ #include <sys/socket.h>
+-#include <sys/poll.h>
+ #include <sys/pollset.h>
+ #include <fcntl.h>
+ #include <stddef.h>
+ #include <dlfcn.h>
+ #include <errno.h>
+ 
++#ifndef MUSL_LIBC
++#include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
++
+ /* Initially copied from src/solaris/native/sun/nio/ch/nio_util.h */
+ #define RESTARTABLE(_cmd, _result) do { \
+   do { \
+diff --git a/jdk/src/macosx/javavm/export/jvm_md.h b/jdk/src/macosx/javavm/export/jvm_md.h
+index 012bb1babe..592bfb5ab9 100644
+--- a/jdk/src/macosx/javavm/export/jvm_md.h
++++ b/jdk/src/macosx/javavm/export/jvm_md.h
+@@ -60,7 +60,12 @@
+ #include <sys/stat.h>
+ #include <fcntl.h>
+ #include <errno.h>
++
++#ifndef MUSL_LIBC
+ #include <sys/signal.h>
++#else
++#include <signal.h>
++#endif
+ 
+ /* O Flags */
+ 
+diff --git a/jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp b/jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp
+index f58c94956c..0afbf6bb98 100644
+--- a/jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp
++++ b/jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp
+@@ -46,6 +46,10 @@
+ 
+ #include "zip.h"
+ 
++#ifdef MUSL_LIBC
++#define uchar unsigned char
++#endif
++
+ #ifdef NO_ZLIB
+ 
+ inline bool jar::deflate_bytes(bytes& head, bytes& tail) {
+diff --git a/jdk/src/share/native/com/sun/java/util/jar/pack/zip.h b/jdk/src/share/native/com/sun/java/util/jar/pack/zip.h
+index 14ffc9d65b..4137714f7d 100644
+--- a/jdk/src/share/native/com/sun/java/util/jar/pack/zip.h
++++ b/jdk/src/share/native/com/sun/java/util/jar/pack/zip.h
+@@ -23,9 +23,13 @@
+  * questions.
+  */
+ 
++#ifndef MUSL_LIBC
+ #define ushort unsigned short
+ #define uint   unsigned int
+ #define uchar  unsigned char
++#else
++#include <sys/types.h>
++#endif
+ 
+ struct unpacker;
+ 
+diff --git a/jdk/src/share/native/sun/awt/medialib/mlib_types.h b/jdk/src/share/native/sun/awt/medialib/mlib_types.h
+index aba0394ffd..ad548aef64 100644
+--- a/jdk/src/share/native/sun/awt/medialib/mlib_types.h
++++ b/jdk/src/share/native/sun/awt/medialib/mlib_types.h
+@@ -27,6 +27,10 @@
+ #ifndef MLIB_TYPES_H
+ #define MLIB_TYPES_H
+ 
++#ifdef MUSL_LIBC
++#include <stddef.h>                     /* for NULL */
++#endif
++
+ #include <limits.h>
+ #if defined(_MSC_VER)
+ #include <float.h>                      /* for FLT_MAX and DBL_MAX */
+diff --git a/jdk/src/solaris/javavm/export/jvm_md.h b/jdk/src/solaris/javavm/export/jvm_md.h
+index 5c681914bb..a181456010 100644
+--- a/jdk/src/solaris/javavm/export/jvm_md.h
++++ b/jdk/src/solaris/javavm/export/jvm_md.h
+@@ -65,7 +65,12 @@
+ #include <sys/stat.h>
+ #include <fcntl.h>
+ #include <errno.h>
++
++#ifndef MUSL_LIBC
+ #include <sys/signal.h>
++#else
++#include <signal.h>
++#endif
+ 
+ /* O Flags */
+ 
+diff --git a/jdk/src/solaris/native/java/net/bsd_close.c b/jdk/src/solaris/native/java/net/bsd_close.c
+index 89a20707c4..73e1a291cf 100644
+--- a/jdk/src/solaris/native/java/net/bsd_close.c
++++ b/jdk/src/solaris/native/java/net/bsd_close.c
+@@ -38,7 +38,12 @@
+ #include <sys/uio.h>
+ #include <unistd.h>
+ #include <errno.h>
++
++#ifndef MUSL_LIBC
+ #include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
+ 
+ /*
+  * Stack allocated by thread when doing blocking operation
+diff --git a/jdk/src/solaris/native/java/net/linux_close.c b/jdk/src/solaris/native/java/net/linux_close.c
+index eacc2afd15..457ac8bdf9 100644
+--- a/jdk/src/solaris/native/java/net/linux_close.c
++++ b/jdk/src/solaris/native/java/net/linux_close.c
+@@ -36,7 +36,12 @@
+ #include <sys/uio.h>
+ #include <unistd.h>
+ #include <errno.h>
++
++#ifndef MUSL_LIBC
+ #include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
+ 
+ /*
+  * Stack allocated by thread when doing blocking operation
+diff --git a/jdk/src/solaris/native/java/net/net_util_md.h b/jdk/src/solaris/native/java/net/net_util_md.h
+index a48446de9c..d0b61a6ba1 100644
+--- a/jdk/src/solaris/native/java/net/net_util_md.h
++++ b/jdk/src/solaris/native/java/net/net_util_md.h
+@@ -33,7 +33,11 @@
+ #include <unistd.h>
+ 
+ #ifndef USE_SELECT
+-#include <sys/poll.h>
++#ifndef MUSL_LIBC
++  #include <sys/poll.h>
++#else
++  #include <poll.h>
++#endif
+ #endif
+ 
+ 
+diff --git a/jdk/src/solaris/native/sun/nio/ch/DevPollArrayWrapper.c b/jdk/src/solaris/native/sun/nio/ch/DevPollArrayWrapper.c
+index 6860a167bb..b581508cf4 100644
+--- a/jdk/src/solaris/native/sun/nio/ch/DevPollArrayWrapper.c
++++ b/jdk/src/solaris/native/sun/nio/ch/DevPollArrayWrapper.c
+@@ -28,10 +28,15 @@
+ #include "jvm.h"
+ #include "jlong.h"
+ #include "sun_nio_ch_DevPollArrayWrapper.h"
+-#include <sys/poll.h>
+ #include <unistd.h>
+ #include <sys/time.h>
+ 
++#ifndef MUSL_LIBC
++#include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
++
+ #ifdef  __cplusplus
+ extern "C" {
+ #endif
+diff --git a/jdk/src/solaris/native/sun/nio/ch/Net.c b/jdk/src/solaris/native/sun/nio/ch/Net.c
+index fcb6197c1d..37f04646bd 100644
+--- a/jdk/src/solaris/native/sun/nio/ch/Net.c
++++ b/jdk/src/solaris/native/sun/nio/ch/Net.c
+@@ -23,7 +23,12 @@
+  * questions.
+  */
+ 
++#ifndef MUSL_LIBC
+ #include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
++
+ #include <sys/types.h>
+ #include <sys/socket.h>
+ #include <string.h>
+diff --git a/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c b/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c
+index 375aaa4850..d2169095a2 100644
+--- a/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c
++++ b/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c
+@@ -32,9 +32,14 @@
+ #include <dlfcn.h>
+ #include <sys/types.h>
+ #include <sys/socket.h>
+-#include <sys/poll.h>
+ #include <sys/inotify.h>
+ 
++#ifndef MUSL_LIBC
++#include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
++
+ #include "sun_nio_fs_LinuxWatchService.h"
+ 
+ static void throwUnixException(JNIEnv* env, int errnum) {
+diff --git a/jdk/src/solaris/transport/socket/socket_md.c b/jdk/src/solaris/transport/socket/socket_md.c
+index 33e062e087..e4f6b56ad4 100644
+--- a/jdk/src/solaris/transport/socket/socket_md.c
++++ b/jdk/src/solaris/transport/socket/socket_md.c
+@@ -34,10 +34,14 @@
+ #include <string.h>
+ #include <sys/time.h>
+ #ifdef __solaris__
+-#include <thread.h>
++  #include <thread.h>
+ #else
+-#include <pthread.h>
+-#include <sys/poll.h>
++  #include <pthread.h>
++  #ifndef MUSL_LIBC
++    #include <sys/poll.h>
++  #else
++    #include <poll.h>
++  #endif
+ #endif
+ 
+ #include "socket_md.h"
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0011-__SIGRTMAX-is-not-defined-in-musl-libc.patch b/patches/alpine-jdk8u/0011-__SIGRTMAX-is-not-defined-in-musl-libc.patch
new file mode 100644
index 0000000..03987cb
--- /dev/null
+++ b/patches/alpine-jdk8u/0011-__SIGRTMAX-is-not-defined-in-musl-libc.patch
@@ -0,0 +1,56 @@
+From eebeb5f6e910c116bdf7fb9b2d264ee00594507d Mon Sep 17 00:00:00 2001
+From: Stephanie Crater <scrater@microsoft.com>
+Date: Mon, 7 Mar 2022 14:43:32 -0800
+Subject: [PATCH] __SIGRTMAX is not defined in musl libc
+
+---
+ jdk/src/solaris/native/java/net/linux_close.c    | 5 ++++-
+ jdk/src/solaris/native/sun/nio/ch/NativeThread.c | 8 ++++++--
+ 2 files changed, 10 insertions(+), 3 deletions(-)
+
+diff --git a/jdk/src/solaris/native/java/net/linux_close.c b/jdk/src/solaris/native/java/net/linux_close.c
+index 457ac8bdf9..fae8a6f084 100644
+--- a/jdk/src/solaris/native/java/net/linux_close.c
++++ b/jdk/src/solaris/native/java/net/linux_close.c
+@@ -63,7 +63,7 @@ typedef struct {
+ /*
+  * Signal to unblock thread
+  */
+-static int sigWakeup = (__SIGRTMAX - 2);
++static int sigWakeup;
+ 
+ /*
+  * fdTable holds one entry per file descriptor, up to a certain
+@@ -152,6 +152,9 @@ static void __attribute((constructor)) init() {
+     /*
+      * Setup the signal handler
+      */
++#ifndef _AIX
++    sigWakeup = SIGRTMAX - 2;
++#endif
+     sa.sa_handler = sig_wakeup;
+     sa.sa_flags   = 0;
+     sigemptyset(&sa.sa_mask);
+diff --git a/jdk/src/solaris/native/sun/nio/ch/NativeThread.c b/jdk/src/solaris/native/sun/nio/ch/NativeThread.c
+index 5e2a78b7af..b512b10aed 100644
+--- a/jdk/src/solaris/native/sun/nio/ch/NativeThread.c
++++ b/jdk/src/solaris/native/sun/nio/ch/NativeThread.c
+@@ -34,9 +34,13 @@
+ 
+ #ifdef __linux__
+   #include <pthread.h>
+-  #include <sys/signal.h>
++  #ifndef MUSL_LIBC
++    #include <sys/signal.h>
++  #else
++    #include <signal.h>
++  #endif
+   /* Also defined in net/linux_close.c */
+-  #define INTERRUPT_SIGNAL (__SIGRTMAX - 2)
++  #define INTERRUPT_SIGNAL (SIGRTMAX - 2)
+ #elif __solaris__
+   #include <thread.h>
+   #include <signal.h>
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0012-Remove-unused-print_stack-void-method.patch b/patches/alpine-jdk8u/0012-Remove-unused-print_stack-void-method.patch
new file mode 100644
index 0000000..9550e19
--- /dev/null
+++ b/patches/alpine-jdk8u/0012-Remove-unused-print_stack-void-method.patch
@@ -0,0 +1,53 @@
+From f5842232ae41cec0422ebc09b8bf76a690a8111f Mon Sep 17 00:00:00 2001
+From: Stephanie Crater <scrater@microsoft.com>
+Date: Mon, 7 Mar 2022 14:23:34 -0800
+Subject: [PATCH] Remove unused print_stack(void) method
+
+---
+ jdk/src/solaris/native/sun/xawt/XToolkit.c | 23 ----------------------
+ 1 file changed, 23 deletions(-)
+
+diff --git a/jdk/src/solaris/native/sun/xawt/XToolkit.c b/jdk/src/solaris/native/sun/xawt/XToolkit.c
+index 24557cba41..1123389585 100644
+--- a/jdk/src/solaris/native/sun/xawt/XToolkit.c
++++ b/jdk/src/solaris/native/sun/xawt/XToolkit.c
+@@ -27,9 +27,6 @@
+ #include <X11/Xutil.h>
+ #include <X11/Xos.h>
+ #include <X11/Xatom.h>
+-#ifdef __linux__
+-#include <execinfo.h>
+-#endif
+ 
+ #include <jvm.h>
+ #include <jni.h>
+@@ -796,26 +793,6 @@ JNIEXPORT jstring JNICALL Java_sun_awt_X11_XToolkit_getEnv
+     return ret;
+ }
+ 
+-#ifdef __linux__
+-void print_stack(void)
+-{
+-  void *array[10];
+-  size_t size;
+-  char **strings;
+-  size_t i;
+-
+-  size = backtrace (array, 10);
+-  strings = backtrace_symbols (array, size);
+-
+-  fprintf (stderr, "Obtained %zd stack frames.\n", size);
+-
+-  for (i = 0; i < size; i++)
+-     fprintf (stderr, "%s\n", strings[i]);
+-
+-  free (strings);
+-}
+-#endif
+-
+ Window get_xawt_root_shell(JNIEnv *env) {
+   static jclass classXRootWindow = NULL;
+   static jmethodID methodGetXRootWindow = NULL;
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0013-Fix-separator-error-in-sa.make.patch b/patches/alpine-jdk8u/0013-Fix-separator-error-in-sa.make.patch
new file mode 100644
index 0000000..e5811bc
--- /dev/null
+++ b/patches/alpine-jdk8u/0013-Fix-separator-error-in-sa.make.patch
@@ -0,0 +1,25 @@
+From db6123c6fb92df7ac2943da6b617eedbd47a90b6 Mon Sep 17 00:00:00 2001
+From: Stephanie Crater <scrater@microsoft.com>
+Date: Tue, 8 Mar 2022 11:49:37 -0800
+Subject: [PATCH] Fix separator error in sa.make
+
+---
+ hotspot/make/linux/makefiles/sa.make | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/hotspot/make/linux/makefiles/sa.make b/hotspot/make/linux/makefiles/sa.make
+index 5c2f661ee1..8d2f31e7cb 100644
+--- a/hotspot/make/linux/makefiles/sa.make
++++ b/hotspot/make/linux/makefiles/sa.make
+@@ -62,7 +62,7 @@ SA_PROPERTIES = $(SA_CLASSDIR)/sa.properties
+ # check for thread_db.h too (musl does not have it).
+ 
+ all: 
+-if [ -d $(AGENT_DIR) -a -f /usr/include/thread_db.h \
++	if [ -d $(AGENT_DIR) -a -f /usr/include/thread_db.h \
+              -a "$(SRCARCH)" != "ia64" \
+              -a "$(SRCARCH)" != "zero" ] ; then \
+ 	   $(MAKE) -f sa.make $(GENERATED)/sa-jdi.jar; \
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0014-Fix-includes-for-musl-on-linux-aarch64.patch b/patches/alpine-jdk8u/0014-Fix-includes-for-musl-on-linux-aarch64.patch
new file mode 100644
index 0000000..4823b27
--- /dev/null
+++ b/patches/alpine-jdk8u/0014-Fix-includes-for-musl-on-linux-aarch64.patch
@@ -0,0 +1,25 @@
+From 2df931ef8b75f00454be99001e6abb5df4f518e8 Mon Sep 17 00:00:00 2001
+From: Stephanie Crater <scrater@microsoft.com>
+Date: Mon, 23 May 2022 10:23:07 -0700
+Subject: [PATCH] Fix includes for musl on linux aarch64
+
+---
+ hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp b/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
+index cf476a0b27..e2cd5e60e7 100644
+--- a/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
++++ b/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
+@@ -73,7 +73,7 @@
+ # include <poll.h>
+ # include <ucontext.h>
+ 
+-#ifdef MUSL_LIBC
++#ifndef MUSL_LIBC
+ #include <fpu_control.h>
+ #else
+ #include <linux/types.h>  /* provides __u64 */
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0015-Regenerate-generated-configure.sh.patch b/patches/alpine-jdk8u/0015-Regenerate-generated-configure.sh.patch
new file mode 100644
index 0000000..19930b7
--- /dev/null
+++ b/patches/alpine-jdk8u/0015-Regenerate-generated-configure.sh.patch
@@ -0,0 +1,270 @@
+From bb6c1b5f95c41f5219ce8353c6110f65b54d5658 Mon Sep 17 00:00:00 2001
+From: Stephanie Crater <scrater@microsoft.com>
+Date: Fri, 13 Jan 2023 15:05:16 -0800
+Subject: [PATCH] Regenerate generated-configure.sh
+
+---
+ common/autoconf/generated-configure.sh | 104 ++++++++++++++++++++-----
+ 1 file changed, 83 insertions(+), 21 deletions(-)
+
+diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
+index c926f7d75e..4b1c9b82b1 100644
+--- a/common/autoconf/generated-configure.sh
++++ b/common/autoconf/generated-configure.sh
+@@ -919,6 +919,7 @@ OPENJDK_TARGET_CPU_LEGACY
+ REQUIRED_OS_VERSION
+ REQUIRED_OS_NAME
+ COMPILE_TYPE
++OPENJDK_TARGET_LIBC
+ OPENJDK_TARGET_CPU_ENDIAN
+ OPENJDK_TARGET_CPU_BITS
+ OPENJDK_TARGET_CPU_ARCH
+@@ -926,6 +927,7 @@ OPENJDK_TARGET_CPU
+ OPENJDK_TARGET_OS_ENV
+ OPENJDK_TARGET_OS_API
+ OPENJDK_TARGET_OS
++OPENJDK_BUILD_LIBC
+ OPENJDK_BUILD_CPU_ENDIAN
+ OPENJDK_BUILD_CPU_BITS
+ OPENJDK_BUILD_CPU_ARCH
+@@ -1015,7 +1017,6 @@ infodir
+ docdir
+ oldincludedir
+ includedir
+-runstatedir
+ localstatedir
+ sharedstatedir
+ sysconfdir
+@@ -1260,7 +1261,6 @@ datadir='${datarootdir}'
+ sysconfdir='${prefix}/etc'
+ sharedstatedir='${prefix}/com'
+ localstatedir='${prefix}/var'
+-runstatedir='${localstatedir}/run'
+ includedir='${prefix}/include'
+ oldincludedir='/usr/include'
+ docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
+@@ -1513,15 +1513,6 @@ do
+   | -silent | --silent | --silen | --sile | --sil)
+     silent=yes ;;
+ 
+-  -runstatedir | --runstatedir | --runstatedi | --runstated \
+-  | --runstate | --runstat | --runsta | --runst | --runs \
+-  | --run | --ru | --r)
+-    ac_prev=runstatedir ;;
+-  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
+-  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
+-  | --run=* | --ru=* | --r=*)
+-    runstatedir=$ac_optarg ;;
+-
+   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+     ac_prev=sbindir ;;
+   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+@@ -1659,7 +1650,7 @@ fi
+ for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
+ 		datadir sysconfdir sharedstatedir localstatedir includedir \
+ 		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+-		libdir localedir mandir runstatedir
++		libdir localedir mandir
+ do
+   eval ac_val=\$$ac_var
+   # Remove trailing slashes.
+@@ -1812,7 +1803,6 @@ Fine tuning of the installation directories:
+   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
+   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
+   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
+-  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
+   --libdir=DIR            object code libraries [EPREFIX/lib]
+   --includedir=DIR        C header files [PREFIX/include]
+   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
+@@ -1919,7 +1909,7 @@ Optional Packages:
+                           Add a custom string to the version string if build
+                           number isn't set.[username_builddateb00]
+   --with-build-number     Set build number value for build [b00]
+-  --with-company-name     Set company name
++  --with-company-name     Set company name.
+   --with-vendor-name      Set vendor name. Among others, used to set the
+                           'java.vendor' and 'java.vm.vendor' system
+                           properties. [not specified]
+@@ -4086,6 +4076,11 @@ fi
+ # VAR_OS and VAR_OS_API.
+ 
+ 
++# Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
++# Converts autoconf style OS name to OpenJDK style, into
++# VAR_LIBC.
++
++
+ # Expects $host_os $host_cpu $build_os and $build_cpu
+ # and $with_target_bits to have been setup!
+ #
+@@ -4419,7 +4414,7 @@ VS_TOOLSET_SUPPORTED_2019=false
+ #CUSTOM_AUTOCONF_INCLUDE
+ 
+ # Do not change or remove the following line, it is needed for consistency checks:
+-DATE_WHEN_GENERATED=1652838310
++DATE_WHEN_GENERATED=1673650816
+ 
+ ###############################################################################
+ #
+@@ -13611,7 +13606,7 @@ test -n "$target_alias" &&
+ 
+ 
+ 
+-  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
++  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
+ 
+   case "$build_os" in
+     *linux*)
+@@ -13728,6 +13723,19 @@ test -n "$target_alias" &&
+       ;;
+   esac
+ 
++
++  case "$build_os" in
++    *linux*-musl)
++      VAR_LIBC=musl
++      ;;
++    *linux*-gnu)
++      VAR_LIBC=gnu
++      ;;
++    *)
++      VAR_LIBC=default
++      ;;
++  esac
++
+   # ..and setup our own variables. (Do this explicitely to facilitate searching)
+   OPENJDK_BUILD_OS="$VAR_OS"
+   OPENJDK_BUILD_OS_API="$VAR_OS_API"
+@@ -13736,6 +13744,8 @@ test -n "$target_alias" &&
+   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
+   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
+   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
++  OPENJDK_BUILD_LIBC="$VAR_LIBC"
++
+ 
+ 
+ 
+@@ -13749,7 +13759,14 @@ $as_echo_n "checking openjdk-build os-cpu... " >&6; }
+   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
+ $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
+ 
+-  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
++  if test "x$OPENJDK_BUILD_OS" = "xlinux"; then
++    { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build C library" >&5
++$as_echo_n "checking openjdk-build C library... " >&6; }
++    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_LIBC" >&5
++$as_echo "$OPENJDK_BUILD_LIBC" >&6; }
++  fi
++
++  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
+ 
+   case "$host_os" in
+     *linux*)
+@@ -13866,6 +13883,19 @@ $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
+       ;;
+   esac
+ 
++
++  case "$host_os" in
++    *linux*-musl)
++      VAR_LIBC=musl
++      ;;
++    *linux*-gnu)
++      VAR_LIBC=gnu
++      ;;
++    *)
++      VAR_LIBC=default
++      ;;
++  esac
++
+   # ... and setup our own variables. (Do this explicitely to facilitate searching)
+   OPENJDK_TARGET_OS="$VAR_OS"
+   OPENJDK_TARGET_OS_API="$VAR_OS_API"
+@@ -13874,6 +13904,8 @@ $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
+   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
+   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
+   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
++  OPENJDK_TARGET_LIBC="$VAR_LIBC"
++
+ 
+ 
+ 
+@@ -13887,6 +13919,13 @@ $as_echo_n "checking openjdk-target os-cpu... " >&6; }
+   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
+ $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
+ 
++  if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
++    { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target C library" >&5
++$as_echo_n "checking openjdk-target C library... " >&6; }
++    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_LIBC" >&5
++$as_echo "$OPENJDK_TARGET_LIBC" >&6; }
++  fi
++
+ 
+ 
+ # Check whether --with-target-bits was given.
+@@ -14648,6 +14687,9 @@ $as_echo "$with_jvm_variants" >&6; }
+ 
+ 
+   INCLUDE_SA=true
++  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
++    INCLUDE_SA=false
++  fi
+   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
+     INCLUDE_SA=false
+   fi
+@@ -20140,6 +20182,19 @@ fi
+ 
+   # Now set the JDK version, milestone, build number etc.
+ 
++
++
++
++
++
++
++
++
++
++
++
++
++
+   # The company name, if any
+ 
+ # Check whether --with-company-name was given.
+@@ -20155,6 +20210,7 @@ fi
+     COMPANY_NAME="$with_company_name"
+   fi
+ 
++
+   # The vendor name, if any
+ 
+ # Check whether --with-vendor-name was given.
+@@ -42252,13 +42308,19 @@ if test "${with_extra_asflags+set}" = set; then :
+ fi
+ 
+ 
+-  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags"
+-  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags"
++  # Define MUSL_LIBC
++  DEFINE_LIBC=""
++  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
++    DEFINE_LIBC="-DMUSL_LIBC"
++  fi
++
++  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags ${DEFINE_LIBC}"
++  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags ${DEFINE_LIBC}"
+   LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
+ 
+   # Hotspot needs these set in their legacy form
+-  LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $with_extra_cflags"
+-  LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $with_extra_cxxflags"
++  LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $with_extra_cflags $DEFINE_LIBC"
++  LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $with_extra_cxxflags $DEFINE_LIBC"
+   LEGACY_EXTRA_LDFLAGS="$LEGACY_EXTRA_LDFLAGS $with_extra_ldflags"
+   LEGACY_EXTRA_ASFLAGS="$with_extra_asflags"
+ 
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0016-Regen-generated-configure.sh-as-contains-conflict-msgs.patch b/patches/alpine-jdk8u/0016-Regen-generated-configure.sh-as-contains-conflict-msgs.patch
new file mode 100644
index 0000000..5f5e415
--- /dev/null
+++ b/patches/alpine-jdk8u/0016-Regen-generated-configure.sh-as-contains-conflict-msgs.patch
@@ -0,0 +1,34 @@
+From e06ef7a848eeadd1ee1969997e304524356b1805 Mon Sep 17 00:00:00 2001
+From: Andrew Leonard <anleonar@redhat.com>
+Date: Thu, 23 Feb 2023 11:17:22 +0000
+Subject: [PATCH] Regen generated-configure.sh as contains conflict msgs
+
+Signed-off-by: Andrew Leonard <anleonar@redhat.com>
+---
+ common/autoconf/generated-configure.sh | 10 +---------
+ 1 file changed, 1 insertion(+), 9 deletions(-)
+
+diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
+index a08bec3219..00a210900a 100644
+--- a/common/autoconf/generated-configure.sh
++++ b/common/autoconf/generated-configure.sh
+@@ -4994,15 +4994,7 @@ VS_TOOLSET_SUPPORTED_2019=false
+ #CUSTOM_AUTOCONF_INCLUDE
+ 
+ # Do not change or remove the following line, it is needed for consistency checks:
+-<<<<<<< HEAD
+-<<<<<<< HEAD
+-DATE_WHEN_GENERATED=1673650816
+-=======
+-DATE_WHEN_GENERATED=1670219878
+->>>>>>> origin/master
+-=======
+-DATE_WHEN_GENERATED=1676455289
+->>>>>>> origin/release
++DATE_WHEN_GENERATED=1677150961
+ 
+ ###############################################################################
+ #
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0017-Regen-generated-configure.sh-as-contains-conflict-msgs.patch b/patches/alpine-jdk8u/0017-Regen-generated-configure.sh-as-contains-conflict-msgs.patch
new file mode 100644
index 0000000..f1e8d29
--- /dev/null
+++ b/patches/alpine-jdk8u/0017-Regen-generated-configure.sh-as-contains-conflict-msgs.patch
@@ -0,0 +1,26 @@
+From 748e72a2784e6062dd4fe2cc624ddf0e4445fe73 Mon Sep 17 00:00:00 2001
+From: Andrew Leonard <anleonar@redhat.com>
+Date: Thu, 23 Feb 2023 11:18:52 +0000
+Subject: [PATCH] Regen generated-configure.sh as contains conflict msgs
+
+Signed-off-by: Andrew Leonard <anleonar@redhat.com>
+---
+ common/autoconf/generated-configure.sh | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
+index e12e97757f..358b389ad0 100644
+--- a/common/autoconf/generated-configure.sh
++++ b/common/autoconf/generated-configure.sh
+@@ -4994,7 +4994,7 @@ VS_TOOLSET_SUPPORTED_2019=false
+ #CUSTOM_AUTOCONF_INCLUDE
+ 
+ # Do not change or remove the following line, it is needed for consistency checks:
+-DATE_WHEN_GENERATED=1676455289
++DATE_WHEN_GENERATED=1677151107
+ 
+ ###############################################################################
+ #
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/0018-Fix-error-in-MUSL-merge-conflict-resolution.patch b/patches/alpine-jdk8u/0018-Fix-error-in-MUSL-merge-conflict-resolution.patch
new file mode 100644
index 0000000..bbdf5c7
--- /dev/null
+++ b/patches/alpine-jdk8u/0018-Fix-error-in-MUSL-merge-conflict-resolution.patch
@@ -0,0 +1,61 @@
+From 8d8cad934909e4ce1dda33eedb476cc62511f143 Mon Sep 17 00:00:00 2001
+From: Andrew Leonard <anleonar@redhat.com>
+Date: Wed, 4 Sep 2024 14:46:37 +0100
+Subject: [PATCH] Fix error in MUSL merge conflict resolution
+
+Signed-off-by: Andrew Leonard <anleonar@redhat.com>
+---
+ common/autoconf/flags.m4               |  8 ++++----
+ common/autoconf/generated-configure.sh | 10 +++++-----
+ 2 files changed, 9 insertions(+), 9 deletions(-)
+
+diff --git a/common/autoconf/flags.m4 b/common/autoconf/flags.m4
+index 46245bafbd..2cef5aa3c5 100644
+--- a/common/autoconf/flags.m4
++++ b/common/autoconf/flags.m4
+@@ -491,10 +491,10 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
+   LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
+ 
+   # Hotspot needs these set in their legacy form
+-  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags"
+-  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags"
+-  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags"
+-  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags"
++  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
++  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
++  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
++  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
+   LEGACY_HOST_LDFLAGS="$LEGACY_HOST_LDFLAGS $with_extra_ldflags"
+   LEGACY_TARGET_LDFLAGS="$LEGACY_TARGET_LDFLAGS $with_extra_ldflags"
+   LEGACY_HOST_ASFLAGS="$with_extra_asflags"
+diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
+index e89a61a6c5..2eb58c981a 100644
+--- a/common/autoconf/generated-configure.sh
++++ b/common/autoconf/generated-configure.sh
+@@ -5016,7 +5016,7 @@ VS_TOOLSET_SUPPORTED_2022=true
+ #CUSTOM_AUTOCONF_INCLUDE
+ 
+ # Do not change or remove the following line, it is needed for consistency checks:
+-DATE_WHEN_GENERATED=1725268775
++DATE_WHEN_GENERATED=1725457575
+ 
+ ###############################################################################
+ #
+@@ -44957,10 +44957,10 @@ fi
+   LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
+ 
+   # Hotspot needs these set in their legacy form
+-  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags"
+-  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags"
+-  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags"
+-  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags"
++  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
++  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
++  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
++  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
+   LEGACY_HOST_LDFLAGS="$LEGACY_HOST_LDFLAGS $with_extra_ldflags"
+   LEGACY_TARGET_LDFLAGS="$LEGACY_TARGET_LDFLAGS $with_extra_ldflags"
+   LEGACY_HOST_ASFLAGS="$with_extra_asflags"
+-- 
+2.52.0
+
diff --git a/patches/alpine-jdk8u/actions-ignore-branches.patch b/patches/alpine-jdk8u/actions-ignore-branches.patch
new file mode 100644
index 0000000..e69de29
diff --git a/skaraMirror.sh b/skaraMirror.sh
index aebcf34..ebf61a1 100755
--- a/skaraMirror.sh
+++ b/skaraMirror.sh
@@ -122,17 +122,19 @@ function performMergeIntoReleaseFromMaster() {
         echo "Skipping top-level $patchName (overridden by patches/$GITHUB_REPO/$patchName)"
       else
         echo "Applying top-level patch: $patchName"
-        git am "$patchFile" || exit 1
+        git am --ignore-whitespace -3 "$patchFile" || exit 1
       fi
     done
 
     # Step 2: Apply repo-specific patches from patches/<GITHUB_REPO>/ if that folder exists
+    # Use --ignore-whitespace -3 for 3-way merge fallback, which handles context mismatches
+    # when patches were generated against an older version of upstream files
     if [ -d "$PATCHES$GITHUB_REPO" ]; then
       for patchFile in "$PATCHES$GITHUB_REPO"/*.patch; do
         [ -f "$patchFile" ] || continue
         patchName=$(basename "$patchFile")
         echo "Applying repo-specific patch: $patchName"
-        git am "$patchFile" || exit 1
+        git am --ignore-whitespace -3 "$patchFile" || exit 1
       done
     fi
   else
@@ -297,10 +299,16 @@ function performMergeIntoDevFromMaster() {
 
 checkArgs $#
 
-SKARA_REPO="https://github.com/openjdk/$1"
 GITHUB_REPO="$1"
 REPO=${2:-"git@github.com:adoptium/$GITHUB_REPO"}
 
+# alpine-jdk8u mirrors from the upstream jdk8u Skara repo
+if [[ "${GITHUB_REPO}" == "alpine-jdk8u" ]]; then
+  SKARA_REPO="https://github.com/openjdk/jdk8u"
+else
+  SKARA_REPO="https://github.com/openjdk/${GITHUB_REPO}"
+fi
+
 # Determine the default branch of the upstream Skara repo via git ls-remote (no API token needed)
 SKARA_DEFAULT_BRANCH=$(git ls-remote --symref "${SKARA_REPO}" HEAD | grep '^ref:' | sed 's|ref: refs/heads/||;s/[[:space:]].*//' | tr -d '[:space:]')
 if [[ -z "${SKARA_DEFAULT_BRANCH}" ]]; then

From 7b84fb43358bb4d9530600cbf19ba438811145bb Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Wed, 26 Aug 2026 13:54:38 +0100
Subject: [PATCH 15/27] chore(mirror_cspu): consolidate alpine musl libc
 support patch

Co-authored-by: Bob <bob@ibm.com>
---
 ...t-C-library-and-define-LIBC-variable.patch |   199 -
 .../0005-alpine-musl-libc-support.patch       | 41877 ++++++++++++++++
 ...Change-glibc_version-to-libc_version.patch |   143 -
 ...07-Don-t-build-SA-if-using-musl-libc.patch |    92 -
 ...Apply-Alpine-s-patches-for-musl-libc.patch |   360 -
 ...ply-Alpine-s-ppc-patch-for-musl-libc.patch |   236 -
 .../0010-Update-includes-for-musl-libc.patch  |   317 -
 ...SIGRTMAX-is-not-defined-in-musl-libc.patch |    56 -
 ...emove-unused-print_stack-void-method.patch |    53 -
 .../0013-Fix-separator-error-in-sa.make.patch |    25 -
 ...x-includes-for-musl-on-linux-aarch64.patch |    25 -
 ...15-Regenerate-generated-configure.sh.patch |   270 -
 ...nfigure.sh-as-contains-conflict-msgs.patch |    34 -
 ...nfigure.sh-as-contains-conflict-msgs.patch |    26 -
 ...or-in-MUSL-merge-conflict-resolution.patch |    61 -
 skaraMirror.sh                                |   104 +-
 16 files changed, 41975 insertions(+), 1903 deletions(-)
 delete mode 100644 patches/alpine-jdk8u/0005-Detect-C-library-and-define-LIBC-variable.patch
 create mode 100644 patches/alpine-jdk8u/0005-alpine-musl-libc-support.patch
 delete mode 100644 patches/alpine-jdk8u/0006-Change-glibc_version-to-libc_version.patch
 delete mode 100644 patches/alpine-jdk8u/0007-Don-t-build-SA-if-using-musl-libc.patch
 delete mode 100644 patches/alpine-jdk8u/0008-Apply-Alpine-s-patches-for-musl-libc.patch
 delete mode 100644 patches/alpine-jdk8u/0009-Apply-Alpine-s-ppc-patch-for-musl-libc.patch
 delete mode 100644 patches/alpine-jdk8u/0010-Update-includes-for-musl-libc.patch
 delete mode 100644 patches/alpine-jdk8u/0011-__SIGRTMAX-is-not-defined-in-musl-libc.patch
 delete mode 100644 patches/alpine-jdk8u/0012-Remove-unused-print_stack-void-method.patch
 delete mode 100644 patches/alpine-jdk8u/0013-Fix-separator-error-in-sa.make.patch
 delete mode 100644 patches/alpine-jdk8u/0014-Fix-includes-for-musl-on-linux-aarch64.patch
 delete mode 100644 patches/alpine-jdk8u/0015-Regenerate-generated-configure.sh.patch
 delete mode 100644 patches/alpine-jdk8u/0016-Regen-generated-configure.sh-as-contains-conflict-msgs.patch
 delete mode 100644 patches/alpine-jdk8u/0017-Regen-generated-configure.sh-as-contains-conflict-msgs.patch
 delete mode 100644 patches/alpine-jdk8u/0018-Fix-error-in-MUSL-merge-conflict-resolution.patch

diff --git a/patches/alpine-jdk8u/0005-Detect-C-library-and-define-LIBC-variable.patch b/patches/alpine-jdk8u/0005-Detect-C-library-and-define-LIBC-variable.patch
deleted file mode 100644
index 7808a5d..0000000
--- a/patches/alpine-jdk8u/0005-Detect-C-library-and-define-LIBC-variable.patch
+++ /dev/null
@@ -1,199 +0,0 @@
-From 129e671a46a50cde80f7aca76fcff8c1357fcd30 Mon Sep 17 00:00:00 2001
-From: Stephanie Crater <scrater@microsoft.com>
-Date: Mon, 7 Mar 2022 17:19:27 -0800
-Subject: [PATCH] Detect C library and define LIBC variable
-
----
- common/autoconf/build-aux/config.guess | 11 ++++++++
- common/autoconf/build-aux/config.sub   |  5 ++++
- common/autoconf/flags.m4               | 14 +++++++---
- common/autoconf/platform.m4            | 38 ++++++++++++++++++++++++--
- common/autoconf/spec.gmk.in            |  4 +++
- 5 files changed, 66 insertions(+), 6 deletions(-)
-
-diff --git a/common/autoconf/build-aux/config.guess b/common/autoconf/build-aux/config.guess
-index 355c91e4eb..5494ba2546 100644
---- a/common/autoconf/build-aux/config.guess
-+++ b/common/autoconf/build-aux/config.guess
-@@ -30,6 +30,17 @@
- DIR=`dirname $0`
- OUT=`. $DIR/autoconf-config.guess`
- 
-+# Detect C library.
-+# Use '-gnu'  suffix on systems that use glibc.
-+# Use '-musl' suffix on systems that use the musl libc.
-+echo $OUT | grep -- -linux- > /dev/null 2> /dev/null
-+if test $? = 0; then
-+  ldd_version=`ldd --version 2>&1 | head -1 | cut -f1 -d' '`
-+  if [ x"${ldd_version}" = x"musl" ]; then
-+    OUT=`echo $OUT | sed 's/-gnu/-musl/'`
-+  fi
-+fi
-+
- # Test and fix solaris on x86_64
- echo $OUT | grep i386-pc-solaris > /dev/null 2> /dev/null
- if test $? = 0; then
-diff --git a/common/autoconf/build-aux/config.sub b/common/autoconf/build-aux/config.sub
-index cc958da946..a665b00fcc 100644
---- a/common/autoconf/build-aux/config.sub
-+++ b/common/autoconf/build-aux/config.sub
-@@ -29,6 +29,11 @@
- 
- DIR=`dirname $0`
- 
-+if echo $* | grep linux-musl >/dev/null ; then
-+    echo $*
-+    exit
-+fi
-+
- # First, filter out everything that doesn't begin with "aarch64-"
- if ! echo $* | grep '^aarch64-' >/dev/null ; then
-     . $DIR/autoconf-config.sub "$@"
-diff --git a/common/autoconf/flags.m4 b/common/autoconf/flags.m4
-index 73b2e76511..4cfaa83d9b 100644
---- a/common/autoconf/flags.m4
-+++ b/common/autoconf/flags.m4
-@@ -474,13 +474,19 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
-   AC_ARG_WITH(extra-asflags, [AS_HELP_STRING([--with-extra-asflags],
-       [extra flags to be passed to the assembler])])
- 
--  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags"
--  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags"
-+  # Define MUSL_LIBC
-+  DEFINE_LIBC=""
-+  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
-+    DEFINE_LIBC="-DMUSL_LIBC"
-+  fi
-+
-+  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags ${DEFINE_LIBC}"
-+  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags ${DEFINE_LIBC}"
-   LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
- 
-   # Hotspot needs these set in their legacy form
--  LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $with_extra_cflags"
--  LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $with_extra_cxxflags"
-+  LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $with_extra_cflags $DEFINE_LIBC"
-+  LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $with_extra_cxxflags $DEFINE_LIBC"
-   LEGACY_EXTRA_LDFLAGS="$LEGACY_EXTRA_LDFLAGS $with_extra_ldflags"
-   LEGACY_EXTRA_ASFLAGS="$with_extra_asflags"
- 
-diff --git a/common/autoconf/platform.m4 b/common/autoconf/platform.m4
-index 51df988f61..a133cfc7a2 100644
---- a/common/autoconf/platform.m4
-+++ b/common/autoconf/platform.m4
-@@ -149,6 +149,24 @@ AC_DEFUN([PLATFORM_EXTRACT_VARS_FROM_OS],
-   esac
- ])
- 
-+# Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
-+# Converts autoconf style OS name to OpenJDK style, into
-+# VAR_LIBC.
-+AC_DEFUN([PLATFORM_EXTRACT_VARS_FROM_LIBC],
-+[
-+  case "$1" in
-+    *linux*-musl)
-+      VAR_LIBC=musl
-+      ;;
-+    *linux*-gnu)
-+      VAR_LIBC=gnu
-+      ;;
-+    *)
-+      VAR_LIBC=default
-+      ;;
-+  esac
-+])
-+
- # Expects $host_os $host_cpu $build_os and $build_cpu
- # and $with_target_bits to have been setup!
- #
-@@ -166,9 +184,10 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
-   AC_SUBST(OPENJDK_TARGET_AUTOCONF_NAME)
-   AC_SUBST(OPENJDK_BUILD_AUTOCONF_NAME)
- 
--  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
-+  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
-   PLATFORM_EXTRACT_VARS_FROM_OS($build_os)
-   PLATFORM_EXTRACT_VARS_FROM_CPU($build_cpu)
-+  PLATFORM_EXTRACT_VARS_FROM_LIBC($build_os)
-   # ..and setup our own variables. (Do this explicitely to facilitate searching)
-   OPENJDK_BUILD_OS="$VAR_OS"
-   OPENJDK_BUILD_OS_API="$VAR_OS_API"
-@@ -177,6 +196,7 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
-   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
-   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
-   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
-+  OPENJDK_BUILD_LIBC="$VAR_LIBC"
-   AC_SUBST(OPENJDK_BUILD_OS)
-   AC_SUBST(OPENJDK_BUILD_OS_API)
-   AC_SUBST(OPENJDK_BUILD_OS_ENV)
-@@ -184,13 +204,20 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
-   AC_SUBST(OPENJDK_BUILD_CPU_ARCH)
-   AC_SUBST(OPENJDK_BUILD_CPU_BITS)
-   AC_SUBST(OPENJDK_BUILD_CPU_ENDIAN)
-+  AC_SUBST(OPENJDK_BUILD_LIBC)
- 
-   AC_MSG_CHECKING([openjdk-build os-cpu])
-   AC_MSG_RESULT([$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU])
- 
--  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
-+  if test "x$OPENJDK_BUILD_OS" = "xlinux"; then
-+    AC_MSG_CHECKING([openjdk-build C library])
-+    AC_MSG_RESULT([$OPENJDK_BUILD_LIBC])
-+  fi
-+
-+  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
-   PLATFORM_EXTRACT_VARS_FROM_OS($host_os)
-   PLATFORM_EXTRACT_VARS_FROM_CPU($host_cpu)
-+  PLATFORM_EXTRACT_VARS_FROM_LIBC($host_os)
-   # ... and setup our own variables. (Do this explicitely to facilitate searching)
-   OPENJDK_TARGET_OS="$VAR_OS"
-   OPENJDK_TARGET_OS_API="$VAR_OS_API"
-@@ -199,6 +226,7 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
-   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
-   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
-   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
-+  OPENJDK_TARGET_LIBC="$VAR_LIBC"
-   AC_SUBST(OPENJDK_TARGET_OS)
-   AC_SUBST(OPENJDK_TARGET_OS_API)
-   AC_SUBST(OPENJDK_TARGET_OS_ENV)
-@@ -206,9 +234,15 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
-   AC_SUBST(OPENJDK_TARGET_CPU_ARCH)
-   AC_SUBST(OPENJDK_TARGET_CPU_BITS)
-   AC_SUBST(OPENJDK_TARGET_CPU_ENDIAN)
-+  AC_SUBST(OPENJDK_TARGET_LIBC)
- 
-   AC_MSG_CHECKING([openjdk-target os-cpu])
-   AC_MSG_RESULT([$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU])
-+
-+  if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
-+    AC_MSG_CHECKING([openjdk-target C library])
-+    AC_MSG_RESULT([$OPENJDK_TARGET_LIBC])
-+  fi
- ])
- 
- # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
-diff --git a/common/autoconf/spec.gmk.in b/common/autoconf/spec.gmk.in
-index 506cf61708..a5da573a73 100644
---- a/common/autoconf/spec.gmk.in
-+++ b/common/autoconf/spec.gmk.in
-@@ -85,6 +85,8 @@ OPENJDK_TARGET_CPU_ARCH:=@OPENJDK_TARGET_CPU_ARCH@
- OPENJDK_TARGET_CPU_BITS:=@OPENJDK_TARGET_CPU_BITS@
- OPENJDK_TARGET_CPU_ENDIAN:=@OPENJDK_TARGET_CPU_ENDIAN@
- 
-+OPENJDK_TARGET_LIBC:=@OPENJDK_TARGET_LIBC@
-+
- COMPILE_TYPE:=@COMPILE_TYPE@
- 
- # Legacy support
-@@ -108,6 +110,8 @@ OPENJDK_BUILD_CPU_ARCH:=@OPENJDK_BUILD_CPU_ARCH@
- OPENJDK_BUILD_CPU_BITS:=@OPENJDK_BUILD_CPU_BITS@
- OPENJDK_BUILD_CPU_ENDIAN:=@OPENJDK_BUILD_CPU_ENDIAN@
- 
-+OPENJDK_BUILD_LIBC:=@OPENJDK_BUILD_LIBC@
-+
- # Legacy OS values for use in release file.
- REQUIRED_OS_NAME:=@REQUIRED_OS_NAME@
- REQUIRED_OS_VERSION:=@REQUIRED_OS_VERSION@
--- 
-2.52.0
-
diff --git a/patches/alpine-jdk8u/0005-alpine-musl-libc-support.patch b/patches/alpine-jdk8u/0005-alpine-musl-libc-support.patch
new file mode 100644
index 0000000..3f014a6
--- /dev/null
+++ b/patches/alpine-jdk8u/0005-alpine-musl-libc-support.patch
@@ -0,0 +1,41877 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Adoptium <adoptium-mirrors@eclipse.org>
+Date: Mon, 17 Sep 2001 00:00:00 +0000
+Subject: [PATCH] Add Alpine/musl libc support
+
+Squashed patch of all Alpine musl libc support changes.
+---
+diff --git a/common/autoconf/build-aux/config.guess b/common/autoconf/build-aux/config.guess
+index b32ca48dd5..5203fcdb29 100644
+--- a/common/autoconf/build-aux/config.guess
++++ b/common/autoconf/build-aux/config.guess
+@@ -30,6 +30,17 @@
+ DIR=`dirname $0`
+ OUT=`. $DIR/autoconf-config.guess`
+ 
++# Detect C library.
++# Use '-gnu'  suffix on systems that use glibc.
++# Use '-musl' suffix on systems that use the musl libc.
++echo $OUT | grep -- -linux- > /dev/null 2> /dev/null
++if test $? = 0; then
++  ldd_version=`ldd --version 2>&1 | head -1 | cut -f1 -d' '`
++  if [ x"${ldd_version}" = x"musl" ]; then
++    OUT=`echo $OUT | sed 's/-gnu/-musl/'`
++  fi
++fi
++
+ # Test and fix solaris on x86_64
+ echo $OUT | grep i386-pc-solaris > /dev/null 2> /dev/null
+ if test $? = 0; then
+diff --git a/common/autoconf/build-aux/config.sub b/common/autoconf/build-aux/config.sub
+index cc958da946..a665b00fcc 100644
+--- a/common/autoconf/build-aux/config.sub
++++ b/common/autoconf/build-aux/config.sub
+@@ -29,6 +29,11 @@
+ 
+ DIR=`dirname $0`
+ 
++if echo $* | grep linux-musl >/dev/null ; then
++    echo $*
++    exit
++fi
++
+ # First, filter out everything that doesn't begin with "aarch64-"
+ if ! echo $* | grep '^aarch64-' >/dev/null ; then
+     . $DIR/autoconf-config.sub "$@"
+diff --git a/common/autoconf/flags.m4 b/common/autoconf/flags.m4
+index 5d1ef8732f..006067fa73 100644
+--- a/common/autoconf/flags.m4
++++ b/common/autoconf/flags.m4
+@@ -450,15 +450,21 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
+   AC_ARG_WITH(extra-asflags, [AS_HELP_STRING([--with-extra-asflags],
+       [extra flags to be passed to the assembler])])
+ 
+-  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags"
+-  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags"
++  # Define MUSL_LIBC
++  DEFINE_LIBC=""
++  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
++    DEFINE_LIBC="-DMUSL_LIBC"
++  fi
++
++  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags ${DEFINE_LIBC}"
++  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags ${DEFINE_LIBC}"
+   LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
+ 
+   # Hotspot needs these set in their legacy form
+-  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags"
+-  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags"
+-  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags"
+-  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags"
++  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
++  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
++  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
++  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
+   LEGACY_HOST_LDFLAGS="$LEGACY_HOST_LDFLAGS $with_extra_ldflags"
+   LEGACY_TARGET_LDFLAGS="$LEGACY_TARGET_LDFLAGS $with_extra_ldflags"
+   LEGACY_HOST_ASFLAGS="$with_extra_asflags"
+diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
+index 344c31649b..9998650ded 100644
+--- a/common/autoconf/generated-configure.sh
++++ b/common/autoconf/generated-configure.sh
+@@ -6,12 +6,13 @@
+ #
+ #! /bin/sh
+ # Guess values for system-dependent variables and create Makefiles.
+-# Generated by GNU Autoconf 2.69 for OpenJDK jdk8.
++# Generated by GNU Autoconf 2.72 for OpenJDK jdk8.
+ #
+ # Report bugs to <build-dev@openjdk.java.net>.
+ #
+ #
+-# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
++# Copyright (C) 1992-1996, 1998-2017, 2020-2023 Free Software Foundation,
++# Inc.
+ #
+ #
+ # This configure script is free software; the Free Software Foundation
+@@ -22,63 +23,65 @@
+ 
+ # Be more Bourne compatible
+ DUALCASE=1; export DUALCASE # for MKS sh
+-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
++if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
++then :
+   emulate sh
+   NULLCMD=:
+   # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+   # is contrary to our usage.  Disable this feature.
+   alias -g '${1+"$@"}'='"$@"'
+   setopt NO_GLOB_SUBST
+-else
+-  case `(set -o) 2>/dev/null` in #(
++else case e in #(
++  e) case `(set -o) 2>/dev/null` in #(
+   *posix*) :
+     set -o posix ;; #(
+   *) :
+      ;;
++esac ;;
+ esac
+ fi
+ 
+ 
++
++# Reset variables that may have inherited troublesome values from
++# the environment.
++
++# IFS needs to be set, to space, tab, and newline, in precisely that order.
++# (If _AS_PATH_WALK were called with IFS unset, it would have the
++# side effect of setting IFS to empty, thus disabling word splitting.)
++# Quoting is to prevent editors from complaining about space-tab.
+ as_nl='
+ '
+ export as_nl
+-# Printing a long string crashes Solaris 7 /usr/bin/printf.
+-as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+-# Prefer a ksh shell builtin over an external printf program on Solaris,
+-# but without wasting forks for bash or zsh.
+-if test -z "$BASH_VERSION$ZSH_VERSION" \
+-    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+-  as_echo='print -r --'
+-  as_echo_n='print -rn --'
+-elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+-  as_echo='printf %s\n'
+-  as_echo_n='printf %s'
+-else
+-  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+-    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+-    as_echo_n='/usr/ucb/echo -n'
+-  else
+-    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+-    as_echo_n_body='eval
+-      arg=$1;
+-      case $arg in #(
+-      *"$as_nl"*)
+-	expr "X$arg" : "X\\(.*\\)$as_nl";
+-	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+-      esac;
+-      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+-    '
+-    export as_echo_n_body
+-    as_echo_n='sh -c $as_echo_n_body as_echo'
+-  fi
+-  export as_echo_body
+-  as_echo='sh -c $as_echo_body as_echo'
+-fi
++IFS=" ""	$as_nl"
++
++PS1='$ '
++PS2='> '
++PS4='+ '
++
++# Ensure predictable behavior from utilities with locale-dependent output.
++LC_ALL=C
++export LC_ALL
++LANGUAGE=C
++export LANGUAGE
++
++# We cannot yet rely on "unset" to work, but we need these variables
++# to be unset--not just set to an empty or harmless value--now, to
++# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh).  This construct
++# also avoids known problems related to "unset" and subshell syntax
++# in other old shells (e.g. bash 2.01 and pdksh 5.2.14).
++for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH
++do eval test \${$as_var+y} \
++  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
++done
++
++# Ensure that fds 0, 1, and 2 are open.
++if (exec 3>&0) 2>/dev/null; then :; else exec 0</dev/null; fi
++if (exec 3>&1) 2>/dev/null; then :; else exec 1>/dev/null; fi
++if (exec 3>&2)            ; then :; else exec 2>/dev/null; fi
+ 
+ # The user is always right.
+-if test "${PATH_SEPARATOR+set}" != set; then
++if ${PATH_SEPARATOR+false} :; then
+   PATH_SEPARATOR=:
+   (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+     (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+@@ -87,13 +90,6 @@ if test "${PATH_SEPARATOR+set}" != set; then
+ fi
+ 
+ 
+-# IFS
+-# We need space, tab and new line, in precisely that order.  Quoting is
+-# there to prevent editors from complaining about space-tab.
+-# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+-# splitting by setting IFS to empty value.)
+-IFS=" ""	$as_nl"
+-
+ # Find who we are.  Look in the path if we contain no directory separator.
+ as_myself=
+ case $0 in #((
+@@ -102,43 +98,27 @@ case $0 in #((
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
++    test -r "$as_dir$0" && as_myself=$as_dir$0 && break
+   done
+ IFS=$as_save_IFS
+ 
+      ;;
+ esac
+-# We did not find ourselves, most probably we were run as `sh COMMAND'
++# We did not find ourselves, most probably we were run as 'sh COMMAND'
+ # in which case we are not to be found in the path.
+ if test "x$as_myself" = x; then
+   as_myself=$0
+ fi
+ if test ! -f "$as_myself"; then
+-  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
++  printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+   exit 1
+ fi
+ 
+-# Unset variables that we do not need and which cause bugs (e.g. in
+-# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+-# suppresses any "Segmentation fault" message there.  '((' could
+-# trigger a bug in pdksh 5.2.14.
+-for as_var in BASH_ENV ENV MAIL MAILPATH
+-do eval test x\${$as_var+set} = xset \
+-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+-done
+-PS1='$ '
+-PS2='> '
+-PS4='+ '
+-
+-# NLS nuisances.
+-LC_ALL=C
+-export LC_ALL
+-LANGUAGE=C
+-export LANGUAGE
+-
+-# CDPATH.
+-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+ 
+ # Use a proper internal environment variable to ensure we don't fall
+   # into an infinite loop, continuously re-executing ourselves.
+@@ -159,26 +139,28 @@ case $- in # ((((
+ esac
+ exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+ # Admittedly, this is quite paranoid, since all the known shells bail
+-# out after a failed `exec'.
+-$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+-as_fn_exit 255
++# out after a failed 'exec'.
++printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
++exit 255
+   fi
+   # We don't want this to propagate to other subprocesses.
+           { _as_can_reexec=; unset _as_can_reexec;}
+ if test "x$CONFIG_SHELL" = x; then
+-  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
++  as_bourne_compatible="if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
++then :
+   emulate sh
+   NULLCMD=:
+   # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
+   # is contrary to our usage.  Disable this feature.
+   alias -g '\${1+\"\$@\"}'='\"\$@\"'
+   setopt NO_GLOB_SUBST
+-else
+-  case \`(set -o) 2>/dev/null\` in #(
++else case e in #(
++  e) case \`(set -o) 2>/dev/null\` in #(
+   *posix*) :
+     set -o posix ;; #(
+   *) :
+      ;;
++esac ;;
+ esac
+ fi
+ "
+@@ -193,42 +175,55 @@ as_fn_success || { exitcode=1; echo as_fn_success failed.; }
+ as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
+ as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
+ as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
+-if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
++if ( set x; as_fn_ret_success y && test x = \"\$1\" )
++then :
+ 
+-else
+-  exitcode=1; echo positional parameters were not saved.
++else case e in #(
++  e) exitcode=1; echo positional parameters were not saved. ;;
++esac
+ fi
+ test x\$exitcode = x0 || exit 1
++blah=\$(echo \$(echo blah))
++test x\"\$blah\" = xblah || exit 1
+ test -x / || exit 1"
+   as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
+   as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
+   eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
+   test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
+ test \$(( 1 + 1 )) = 2 || exit 1"
+-  if (eval "$as_required") 2>/dev/null; then :
++  if (eval "$as_required") 2>/dev/null
++then :
+   as_have_required=yes
+-else
+-  as_have_required=no
++else case e in #(
++  e) as_have_required=no ;;
++esac
+ fi
+-  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
++  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null
++then :
+ 
+-else
+-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++else case e in #(
++  e) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ as_found=false
+ for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+   as_found=:
+   case $as_dir in #(
+ 	 /*)
+ 	   for as_base in sh bash ksh sh5; do
+ 	     # Try only shells that exist, to save several forks.
+-	     as_shell=$as_dir/$as_base
++	     as_shell=$as_dir$as_base
+ 	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
+-		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
++		    as_run=a "$as_shell" -c "$as_bourne_compatible""$as_required" 2>/dev/null
++then :
+   CONFIG_SHELL=$as_shell as_have_required=yes
+-		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
++		   if as_run=a "$as_shell" -c "$as_bourne_compatible""$as_suggested" 2>/dev/null
++then :
+   break 2
+ fi
+ fi
+@@ -236,14 +231,22 @@ fi
+        esac
+   as_found=false
+ done
+-$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
+-	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
+-  CONFIG_SHELL=$SHELL as_have_required=yes
+-fi; }
+ IFS=$as_save_IFS
++if $as_found
++then :
++
++else case e in #(
++  e) if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
++	      as_run=a "$SHELL" -c "$as_bourne_compatible""$as_required" 2>/dev/null
++then :
++  CONFIG_SHELL=$SHELL as_have_required=yes
++fi ;;
++esac
++fi
+ 
+ 
+-      if test "x$CONFIG_SHELL" != x; then :
++      if test "x$CONFIG_SHELL" != x
++then :
+   export CONFIG_SHELL
+              # We cannot yet assume a decent shell, so we have to provide a
+ # neutralization value for shells without unset; and this also
+@@ -260,26 +263,28 @@ case $- in # ((((
+ esac
+ exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+ # Admittedly, this is quite paranoid, since all the known shells bail
+-# out after a failed `exec'.
+-$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
++# out after a failed 'exec'.
++printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
+ exit 255
+ fi
+ 
+-    if test x$as_have_required = xno; then :
+-  $as_echo "$0: This script requires a shell more modern than all"
+-  $as_echo "$0: the shells that I found on your system."
+-  if test x${ZSH_VERSION+set} = xset ; then
+-    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
+-    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
++    if test x$as_have_required = xno
++then :
++  printf "%s\n" "$0: This script requires a shell more modern than all"
++  printf "%s\n" "$0: the shells that I found on your system."
++  if test ${ZSH_VERSION+y} ; then
++    printf "%s\n" "$0: In particular, zsh $ZSH_VERSION has bugs and should"
++    printf "%s\n" "$0: be upgraded to zsh 4.3.4 or later."
+   else
+-    $as_echo "$0: Please tell bug-autoconf@gnu.org and
++    printf "%s\n" "$0: Please tell bug-autoconf@gnu.org and
+ $0: build-dev@openjdk.java.net about your system, including
+ $0: any error possibly output before this message. Then
+ $0: install a modern shell, or manually run the script
+ $0: under such a shell if you do have one."
+   fi
+   exit 1
+-fi
++fi ;;
++esac
+ fi
+ fi
+ SHELL=${CONFIG_SHELL-/bin/sh}
+@@ -300,6 +305,7 @@ as_fn_unset ()
+ }
+ as_unset=as_fn_unset
+ 
++
+ # as_fn_set_status STATUS
+ # -----------------------
+ # Set $? to STATUS, without forking.
+@@ -331,7 +337,7 @@ as_fn_mkdir_p ()
+     as_dirs=
+     while :; do
+       case $as_dir in #(
+-      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
++      *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+       *) as_qdir=$as_dir;;
+       esac
+       as_dirs="'$as_qdir' $as_dirs"
+@@ -340,7 +346,7 @@ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ 	 X"$as_dir" : 'X\(//\)[^/]' \| \
+ 	 X"$as_dir" : 'X\(//\)$' \| \
+ 	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+-$as_echo X"$as_dir" |
++printf "%s\n" X"$as_dir" |
+     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ 	    s//\1/
+ 	    q
+@@ -379,16 +385,18 @@ as_fn_executable_p ()
+ # advantage of any shell optimizations that allow amortized linear growth over
+ # repeated appends, instead of the typical quadratic growth present in naive
+ # implementations.
+-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
++if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null
++then :
+   eval 'as_fn_append ()
+   {
+     eval $1+=\$2
+   }'
+-else
+-  as_fn_append ()
++else case e in #(
++  e) as_fn_append ()
+   {
+     eval $1=\$$1\$2
+-  }
++  } ;;
++esac
+ fi # as_fn_append
+ 
+ # as_fn_arith ARG...
+@@ -396,16 +404,18 @@ fi # as_fn_append
+ # Perform arithmetic evaluation on the ARGs, and store the result in the
+ # global $as_val. Take advantage of shells that can avoid forks. The arguments
+ # must be portable across $(()) and expr.
+-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
++if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null
++then :
+   eval 'as_fn_arith ()
+   {
+     as_val=$(( $* ))
+   }'
+-else
+-  as_fn_arith ()
++else case e in #(
++  e) as_fn_arith ()
+   {
+     as_val=`expr "$@" || test $? -eq 1`
+-  }
++  } ;;
++esac
+ fi # as_fn_arith
+ 
+ 
+@@ -419,9 +429,9 @@ as_fn_error ()
+   as_status=$1; test $as_status -eq 0 && as_status=1
+   if test "$4"; then
+     as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+   fi
+-  $as_echo "$as_me: error: $2" >&2
++  printf "%s\n" "$as_me: error: $2" >&2
+   as_fn_exit $as_status
+ } # as_fn_error
+ 
+@@ -448,7 +458,7 @@ as_me=`$as_basename -- "$0" ||
+ $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+ 	 X"$0" : 'X\(//\)$' \| \
+ 	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+-$as_echo X/"$0" |
++printf "%s\n" X/"$0" |
+     sed '/^.*\/\([^/][^/]*\)\/*$/{
+ 	    s//\1/
+ 	    q
+@@ -481,6 +491,8 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits
+     /[$]LINENO/=
+   ' <$as_myself |
+     sed '
++      t clear
++      :clear
+       s/[$]LINENO.*/&-/
+       t lineno
+       b
+@@ -492,7 +504,7 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits
+       s/-\n.*//
+     ' >$as_me.lineno &&
+   chmod +x "$as_me.lineno" ||
+-    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
++    { printf "%s\n" "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
+ 
+   # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
+   # already done that, so ensure we don't try to do so again and fall
+@@ -506,6 +518,10 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits
+   exit
+ }
+ 
++
++# Determine whether it's possible to make 'echo' print without a newline.
++# These variables are no longer used directly by Autoconf, but are AC_SUBSTed
++# for compatibility with existing Makefiles.
+ ECHO_C= ECHO_N= ECHO_T=
+ case `echo -n x` in #(((((
+ -n*)
+@@ -519,6 +535,12 @@ case `echo -n x` in #(((((
+   ECHO_N='-n';;
+ esac
+ 
++# For backward compatibility with old third-party macros, we provide
++# the shell variables $as_echo and $as_echo_n.  New code should use
++# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively.
++as_echo='printf %s\n'
++as_echo_n='printf %s'
++
+ rm -f conf$$ conf$$.exe conf$$.file
+ if test -d conf$$.dir; then
+   rm -f conf$$.dir/conf$$.file
+@@ -530,9 +552,9 @@ if (echo >conf$$.file) 2>/dev/null; then
+   if ln -s conf$$.file conf$$ 2>/dev/null; then
+     as_ln_s='ln -s'
+     # ... but there are two gotchas:
+-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+-    # In both cases, we have to default to `cp -pR'.
++    # 1) On MSYS, both 'ln -s file dir' and 'ln file dir' fail.
++    # 2) DJGPP < 2.04 has no symlinks; 'ln -s' creates a wrapper executable.
++    # In both cases, we have to default to 'cp -pR'.
+     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+       as_ln_s='cp -pR'
+   elif ln conf$$.file conf$$ 2>/dev/null; then
+@@ -557,10 +579,12 @@ as_test_x='test -x'
+ as_executable_p=as_fn_executable_p
+ 
+ # Sed expression to map a string onto a valid CPP name.
+-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
++as_sed_cpp="y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
++as_tr_cpp="eval sed '$as_sed_cpp'" # deprecated
+ 
+ # Sed expression to map a string onto a valid variable name.
+-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
++as_sed_sh="y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
++as_tr_sh="eval sed '$as_sed_sh'" # deprecated
+ 
+ 
+ test -n "$DJDIR" || exec 7<&0 </dev/null
+@@ -593,40 +617,36 @@ PACKAGE_URL='http://openjdk.java.net'
+ 
+ # Factoring default headers for most tests.
+ ac_includes_default="\
+-#include <stdio.h>
+-#ifdef HAVE_SYS_TYPES_H
+-# include <sys/types.h>
+-#endif
+-#ifdef HAVE_SYS_STAT_H
+-# include <sys/stat.h>
++#include <stddef.h>
++#ifdef HAVE_STDIO_H
++# include <stdio.h>
+ #endif
+-#ifdef STDC_HEADERS
++#ifdef HAVE_STDLIB_H
+ # include <stdlib.h>
+-# include <stddef.h>
+-#else
+-# ifdef HAVE_STDLIB_H
+-#  include <stdlib.h>
+-# endif
+ #endif
+ #ifdef HAVE_STRING_H
+-# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+-#  include <memory.h>
+-# endif
+ # include <string.h>
+ #endif
+-#ifdef HAVE_STRINGS_H
+-# include <strings.h>
+-#endif
+ #ifdef HAVE_INTTYPES_H
+ # include <inttypes.h>
+ #endif
+ #ifdef HAVE_STDINT_H
+ # include <stdint.h>
+ #endif
++#ifdef HAVE_STRINGS_H
++# include <strings.h>
++#endif
++#ifdef HAVE_SYS_TYPES_H
++# include <sys/types.h>
++#endif
++#ifdef HAVE_SYS_STAT_H
++# include <sys/stat.h>
++#endif
+ #ifdef HAVE_UNISTD_H
+ # include <unistd.h>
+ #endif"
+ 
++ac_header_cxx_list=
+ ac_subst_vars='LTLIBOBJS
+ LIBOBJS
+ CCACHE
+@@ -924,6 +944,7 @@ OPENJDK_TARGET_CPU_LEGACY
+ REQUIRED_OS_VERSION
+ REQUIRED_OS_NAME
+ COMPILE_TYPE
++OPENJDK_TARGET_LIBC
+ OPENJDK_TARGET_CPU_ENDIAN
+ OPENJDK_TARGET_CPU_BITS
+ OPENJDK_TARGET_CPU_ARCH
+@@ -931,6 +952,7 @@ OPENJDK_TARGET_CPU
+ OPENJDK_TARGET_OS_ENV
+ OPENJDK_TARGET_OS_API
+ OPENJDK_TARGET_OS
++OPENJDK_BUILD_LIBC
+ OPENJDK_BUILD_CPU_ENDIAN
+ OPENJDK_BUILD_CPU_BITS
+ OPENJDK_BUILD_CPU_ARCH
+@@ -1021,6 +1043,7 @@ infodir
+ docdir
+ oldincludedir
+ includedir
++runstatedir
+ localstatedir
+ sharedstatedir
+ sysconfdir
+@@ -1072,6 +1095,7 @@ with_milestone
+ with_update_version
+ with_user_release_suffix
+ with_build_number
++with_company_name
+ with_vendor_name
+ with_vendor_url
+ with_vendor_bug_url
+@@ -1264,6 +1288,7 @@ datadir='${datarootdir}'
+ sysconfdir='${prefix}/etc'
+ sharedstatedir='${prefix}/com'
+ localstatedir='${prefix}/var'
++runstatedir='${localstatedir}/run'
+ includedir='${prefix}/include'
+ oldincludedir='/usr/include'
+ docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
+@@ -1293,8 +1318,6 @@ do
+   *)    ac_optarg=yes ;;
+   esac
+ 
+-  # Accept the important Cygnus configure options, so we can diagnose typos.
+-
+   case $ac_dashdash$ac_option in
+   --)
+     ac_dashdash=yes ;;
+@@ -1335,9 +1358,9 @@ do
+     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
+     # Reject names that are not valid shell variable names.
+     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+-      as_fn_error $? "invalid feature name: $ac_useropt"
++      as_fn_error $? "invalid feature name: '$ac_useropt'"
+     ac_useropt_orig=$ac_useropt
+-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
++    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
+     case $ac_user_opts in
+       *"
+ "enable_$ac_useropt"
+@@ -1361,9 +1384,9 @@ do
+     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
+     # Reject names that are not valid shell variable names.
+     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+-      as_fn_error $? "invalid feature name: $ac_useropt"
++      as_fn_error $? "invalid feature name: '$ac_useropt'"
+     ac_useropt_orig=$ac_useropt
+-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
++    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
+     case $ac_user_opts in
+       *"
+ "enable_$ac_useropt"
+@@ -1516,6 +1539,15 @@ do
+   | -silent | --silent | --silen | --sile | --sil)
+     silent=yes ;;
+ 
++  -runstatedir | --runstatedir | --runstatedi | --runstated \
++  | --runstate | --runstat | --runsta | --runst | --runs \
++  | --run | --ru | --r)
++    ac_prev=runstatedir ;;
++  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
++  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
++  | --run=* | --ru=* | --r=*)
++    runstatedir=$ac_optarg ;;
++
+   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+     ac_prev=sbindir ;;
+   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+@@ -1565,9 +1597,9 @@ do
+     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
+     # Reject names that are not valid shell variable names.
+     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+-      as_fn_error $? "invalid package name: $ac_useropt"
++      as_fn_error $? "invalid package name: '$ac_useropt'"
+     ac_useropt_orig=$ac_useropt
+-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
++    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
+     case $ac_user_opts in
+       *"
+ "with_$ac_useropt"
+@@ -1581,9 +1613,9 @@ do
+     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
+     # Reject names that are not valid shell variable names.
+     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
+-      as_fn_error $? "invalid package name: $ac_useropt"
++      as_fn_error $? "invalid package name: '$ac_useropt'"
+     ac_useropt_orig=$ac_useropt
+-    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
++    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
+     case $ac_user_opts in
+       *"
+ "with_$ac_useropt"
+@@ -1611,8 +1643,8 @@ do
+   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+     x_libraries=$ac_optarg ;;
+ 
+-  -*) as_fn_error $? "unrecognized option: \`$ac_option'
+-Try \`$0 --help' for more information"
++  -*) as_fn_error $? "unrecognized option: '$ac_option'
++Try '$0 --help' for more information"
+     ;;
+ 
+   *=*)
+@@ -1620,16 +1652,16 @@ Try \`$0 --help' for more information"
+     # Reject names that are not valid shell variable names.
+     case $ac_envvar in #(
+       '' | [0-9]* | *[!_$as_cr_alnum]* )
+-      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
++      as_fn_error $? "invalid variable name: '$ac_envvar'" ;;
+     esac
+     eval $ac_envvar=\$ac_optarg
+     export $ac_envvar ;;
+ 
+   *)
+     # FIXME: should be removed in autoconf 3.0.
+-    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
++    printf "%s\n" "$as_me: WARNING: you should use --build, --host, --target" >&2
+     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
+-      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
++      printf "%s\n" "$as_me: WARNING: invalid host type: $ac_option" >&2
+     : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
+     ;;
+ 
+@@ -1645,7 +1677,7 @@ if test -n "$ac_unrecognized_opts"; then
+   case $enable_option_checking in
+     no) ;;
+     fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
+-    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
++    *)     printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
+   esac
+ fi
+ 
+@@ -1653,7 +1685,7 @@ fi
+ for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
+ 		datadir sysconfdir sharedstatedir localstatedir includedir \
+ 		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+-		libdir localedir mandir
++		libdir localedir mandir runstatedir
+ do
+   eval ac_val=\$$ac_var
+   # Remove trailing slashes.
+@@ -1670,7 +1702,7 @@ do
+   as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
+ done
+ 
+-# There might be people who depend on the old broken behavior: `$host'
++# There might be people who depend on the old broken behavior: '$host'
+ # used to hold the argument of --host etc.
+ # FIXME: To remove some day.
+ build=$build_alias
+@@ -1709,7 +1741,7 @@ $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ 	 X"$as_myself" : 'X\(//\)[^/]' \| \
+ 	 X"$as_myself" : 'X\(//\)$' \| \
+ 	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
+-$as_echo X"$as_myself" |
++printf "%s\n" X"$as_myself" |
+     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ 	    s//\1/
+ 	    q
+@@ -1738,7 +1770,7 @@ if test ! -r "$srcdir/$ac_unique_file"; then
+   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
+   as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
+ fi
+-ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
++ac_msg="sources are in $srcdir, but 'cd $srcdir' does not work"
+ ac_abs_confdir=`(
+ 	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
+ 	pwd)`
+@@ -1766,7 +1798,7 @@ if test "$ac_init_help" = "long"; then
+   # Omit some internal or obsolete options to make the list less imposing.
+   # This message is too long to be a string in the A/UX 3.1 sh.
+   cat <<_ACEOF
+-\`configure' configures OpenJDK jdk8 to adapt to many kinds of systems.
++'configure' configures OpenJDK jdk8 to adapt to many kinds of systems.
+ 
+ Usage: $0 [OPTION]... [VAR=VALUE]...
+ 
+@@ -1780,11 +1812,11 @@ Configuration:
+       --help=short        display options specific to this package
+       --help=recursive    display the short help of all the included packages
+   -V, --version           display version information and exit
+-  -q, --quiet, --silent   do not print \`checking ...' messages
++  -q, --quiet, --silent   do not print 'checking ...' messages
+       --cache-file=FILE   cache test results in FILE [disabled]
+-  -C, --config-cache      alias for \`--cache-file=config.cache'
++  -C, --config-cache      alias for '--cache-file=config.cache'
+   -n, --no-create         do not create output files
+-      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
++      --srcdir=DIR        find the sources in DIR [configure dir or '..']
+ 
+ Installation directories:
+   --prefix=PREFIX         install architecture-independent files in PREFIX
+@@ -1792,10 +1824,10 @@ Installation directories:
+   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+                           [PREFIX]
+ 
+-By default, \`make install' will install all the files in
+-\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
+-an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+-for instance \`--prefix=\$HOME'.
++By default, 'make install' will install all the files in
++'$ac_default_prefix/bin', '$ac_default_prefix/lib' etc.  You can specify
++an installation prefix other than '$ac_default_prefix' using '--prefix',
++for instance '--prefix=\$HOME'.
+ 
+ For better control, use the options below.
+ 
+@@ -1806,6 +1838,7 @@ Fine tuning of the installation directories:
+   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
+   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
+   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
++  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
+   --libdir=DIR            object code libraries [EPREFIX/lib]
+   --includedir=DIR        C header files [PREFIX/include]
+   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
+@@ -1908,6 +1941,7 @@ Optional Packages:
+                           Add a custom string to the version string if build
+                           number isn't set.[username_builddateb00]
+   --with-build-number     Set build number value for build [b00]
++  --with-company-name     Set company name.
+   --with-vendor-name      Set vendor name. Among others, used to set the
+                           'java.vendor' and 'java.vm.vendor' system
+                           properties. [not specified]
+@@ -2114,7 +2148,7 @@ Some influential environment variables:
+   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
+   CCACHE      Override default value for CCACHE
+ 
+-Use these variables to override the choices made by `configure' or to help
++Use these variables to override the choices made by 'configure' or to help
+ it to find libraries and programs with nonstandard names/locations.
+ 
+ Report bugs to <build-dev@openjdk.java.net>.
+@@ -2134,9 +2168,9 @@ if test "$ac_init_help" = "recursive"; then
+ case "$ac_dir" in
+ .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+ *)
+-  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
++  ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'`
+   # A ".." for each directory in $ac_dir_suffix.
+-  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
++  ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+   case $ac_top_builddir_sub in
+   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+@@ -2164,7 +2198,8 @@ esac
+ ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+ 
+     cd "$ac_dir" || { ac_status=$?; continue; }
+-    # Check for guested configure.
++    # Check for configure.gnu first; this name is used for a wrapper for
++    # Metaconfig's "Configure" on case-insensitive file systems.
+     if test -f "$ac_srcdir/configure.gnu"; then
+       echo &&
+       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
+@@ -2172,7 +2207,7 @@ ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+       echo &&
+       $SHELL "$ac_srcdir/configure" --help=recursive
+     else
+-      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
++      printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+     fi || ac_status=$?
+     cd "$ac_pwd" || { ac_status=$?; break; }
+   done
+@@ -2182,9 +2217,9 @@ test -n "$ac_init_help" && exit $ac_status
+ if $ac_init_version; then
+   cat <<\_ACEOF
+ OpenJDK configure jdk8
+-generated by GNU Autoconf 2.69
++generated by GNU Autoconf 2.72
+ 
+-Copyright (C) 2012 Free Software Foundation, Inc.
++Copyright (C) 2023 Free Software Foundation, Inc.
+ This configure script is free software; the Free Software Foundation
+ gives unlimited permission to copy, distribute and modify it.
+ _ACEOF
+@@ -2201,14 +2236,14 @@ fi
+ ac_fn_c_try_compile ()
+ {
+   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+-  rm -f conftest.$ac_objext
++  rm -f conftest.$ac_objext conftest.beam
+   if { { ac_try="$ac_compile"
+ case "(($ac_try" in
+   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_compile") 2>conftest.err
+   ac_status=$?
+   if test -s conftest.err; then
+@@ -2216,17 +2251,19 @@ $as_echo "$ac_try_echo"; } >&5
+     cat conftest.er1 >&5
+     mv -f conftest.er1 conftest.err
+   fi
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; } && {
+ 	 test -z "$ac_c_werror_flag" ||
+ 	 test ! -s conftest.err
+-       } && test -s conftest.$ac_objext; then :
++       } && test -s conftest.$ac_objext
++then :
+   ac_retval=0
+-else
+-  $as_echo "$as_me: failed program was:" >&5
++else case e in #(
++  e) printf "%s\n" "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+ 
+-	ac_retval=1
++	ac_retval=1 ;;
++esac
+ fi
+   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+   as_fn_set_status $ac_retval
+@@ -2239,14 +2276,14 @@ fi
+ ac_fn_cxx_try_compile ()
+ {
+   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+-  rm -f conftest.$ac_objext
++  rm -f conftest.$ac_objext conftest.beam
+   if { { ac_try="$ac_compile"
+ case "(($ac_try" in
+   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_compile") 2>conftest.err
+   ac_status=$?
+   if test -s conftest.err; then
+@@ -2254,17 +2291,19 @@ $as_echo "$ac_try_echo"; } >&5
+     cat conftest.er1 >&5
+     mv -f conftest.er1 conftest.err
+   fi
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; } && {
+ 	 test -z "$ac_cxx_werror_flag" ||
+ 	 test ! -s conftest.err
+-       } && test -s conftest.$ac_objext; then :
++       } && test -s conftest.$ac_objext
++then :
+   ac_retval=0
+-else
+-  $as_echo "$as_me: failed program was:" >&5
++else case e in #(
++  e) printf "%s\n" "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+ 
+-	ac_retval=1
++	ac_retval=1 ;;
++esac
+ fi
+   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+   as_fn_set_status $ac_retval
+@@ -2283,7 +2322,7 @@ case "(($ac_try" in
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+   ac_status=$?
+   if test -s conftest.err; then
+@@ -2291,17 +2330,19 @@ $as_echo "$ac_try_echo"; } >&5
+     cat conftest.er1 >&5
+     mv -f conftest.er1 conftest.err
+   fi
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; } > conftest.i && {
+ 	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+ 	 test ! -s conftest.err
+-       }; then :
++       }
++then :
+   ac_retval=0
+-else
+-  $as_echo "$as_me: failed program was:" >&5
++else case e in #(
++  e) printf "%s\n" "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+ 
+-    ac_retval=1
++    ac_retval=1 ;;
++esac
+ fi
+   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+   as_fn_set_status $ac_retval
+@@ -2320,7 +2361,7 @@ case "(($ac_try" in
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+   ac_status=$?
+   if test -s conftest.err; then
+@@ -2328,17 +2369,19 @@ $as_echo "$ac_try_echo"; } >&5
+     cat conftest.er1 >&5
+     mv -f conftest.er1 conftest.err
+   fi
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; } > conftest.i && {
+ 	 test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
+ 	 test ! -s conftest.err
+-       }; then :
++       }
++then :
+   ac_retval=0
+-else
+-  $as_echo "$as_me: failed program was:" >&5
++else case e in #(
++  e) printf "%s\n" "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+ 
+-    ac_retval=1
++    ac_retval=1 ;;
++esac
+ fi
+   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+   as_fn_set_status $ac_retval
+@@ -2351,14 +2394,14 @@ fi
+ ac_fn_objc_try_compile ()
+ {
+   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+-  rm -f conftest.$ac_objext
++  rm -f conftest.$ac_objext conftest.beam
+   if { { ac_try="$ac_compile"
+ case "(($ac_try" in
+   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_compile") 2>conftest.err
+   ac_status=$?
+   if test -s conftest.err; then
+@@ -2366,118 +2409,64 @@ $as_echo "$ac_try_echo"; } >&5
+     cat conftest.er1 >&5
+     mv -f conftest.er1 conftest.err
+   fi
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; } && {
+ 	 test -z "$ac_objc_werror_flag" ||
+ 	 test ! -s conftest.err
+-       } && test -s conftest.$ac_objext; then :
++       } && test -s conftest.$ac_objext
++then :
+   ac_retval=0
+-else
+-  $as_echo "$as_me: failed program was:" >&5
++else case e in #(
++  e) printf "%s\n" "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+ 
+-	ac_retval=1
++	ac_retval=1 ;;
++esac
+ fi
+   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+   as_fn_set_status $ac_retval
+ 
+ } # ac_fn_objc_try_compile
+ 
+-# ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
++# ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
+ # ---------------------------------------------------------
+-# Tests whether HEADER exists, giving a warning if it cannot be compiled using
+-# the include files in INCLUDES and setting the cache variable VAR
+-# accordingly.
+-ac_fn_cxx_check_header_mongrel ()
++# Tests whether HEADER exists and can be compiled using the include files in
++# INCLUDES, setting the cache variable VAR accordingly.
++ac_fn_cxx_check_header_compile ()
+ {
+   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+-  if eval \${$3+:} false; then :
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+-$as_echo_n "checking for $2... " >&6; }
+-if eval \${$3+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-fi
+-eval ac_res=\$$3
+-	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+-$as_echo "$ac_res" >&6; }
+-else
+-  # Is the header compilable?
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
+-$as_echo_n "checking $2 usability... " >&6; }
+-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
++printf %s "checking for $2... " >&6; }
++if eval test \${$3+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ $4
+ #include <$2>
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
+-  ac_header_compiler=yes
+-else
+-  ac_header_compiler=no
+-fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
+-$as_echo "$ac_header_compiler" >&6; }
+-
+-# Is the header present?
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
+-$as_echo_n "checking $2 presence... " >&6; }
+-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+-/* end confdefs.h.  */
+-#include <$2>
+-_ACEOF
+-if ac_fn_cxx_try_cpp "$LINENO"; then :
+-  ac_header_preproc=yes
+-else
+-  ac_header_preproc=no
++if ac_fn_cxx_try_compile "$LINENO"
++then :
++  eval "$3=yes"
++else case e in #(
++  e) eval "$3=no" ;;
++esac
+ fi
+-rm -f conftest.err conftest.i conftest.$ac_ext
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
+-$as_echo "$ac_header_preproc" >&6; }
+-
+-# So?  What about this header?
+-case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
+-  yes:no: )
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
+-$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+-$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+-    ;;
+-  no:yes:* )
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
+-$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
+-$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
+-$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
+-$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+-$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+-( $as_echo "## ----------------------------------------- ##
+-## Report this to build-dev@openjdk.java.net ##
+-## ----------------------------------------- ##"
+-     ) | sed "s/^/$as_me: WARNING:     /" >&2
+-    ;;
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
+ esac
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+-$as_echo_n "checking for $2... " >&6; }
+-if eval \${$3+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  eval "$3=\$ac_header_compiler"
+ fi
+ eval ac_res=\$$3
+-	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+-$as_echo "$ac_res" >&6; }
+-fi
++	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
++printf "%s\n" "$ac_res" >&6; }
+   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+ 
+-} # ac_fn_cxx_check_header_mongrel
++} # ac_fn_cxx_check_header_compile
+ 
+ # ac_fn_cxx_try_run LINENO
+ # ------------------------
+-# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
+-# that executables *can* be run.
++# Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that
++# executables *can* be run.
+ ac_fn_cxx_try_run ()
+ {
+   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+@@ -2487,28 +2476,30 @@ case "(($ac_try" in
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_link") 2>&5
+   ac_status=$?
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
+   { { case "(($ac_try" in
+   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_try") 2>&5
+   ac_status=$?
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+-  test $ac_status = 0; }; }; then :
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  test $ac_status = 0; }; }
++then :
+   ac_retval=0
+-else
+-  $as_echo "$as_me: program exited with status $ac_status" >&5
+-       $as_echo "$as_me: failed program was:" >&5
++else case e in #(
++  e) printf "%s\n" "$as_me: program exited with status $ac_status" >&5
++       printf "%s\n" "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+ 
+-       ac_retval=$ac_status
++       ac_retval=$ac_status ;;
++esac
+ fi
+   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+@@ -2516,37 +2507,6 @@ fi
+ 
+ } # ac_fn_cxx_try_run
+ 
+-# ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
+-# ---------------------------------------------------------
+-# Tests whether HEADER exists and can be compiled using the include files in
+-# INCLUDES, setting the cache variable VAR accordingly.
+-ac_fn_cxx_check_header_compile ()
+-{
+-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+-$as_echo_n "checking for $2... " >&6; }
+-if eval \${$3+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+-/* end confdefs.h.  */
+-$4
+-#include <$2>
+-_ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
+-  eval "$3=yes"
+-else
+-  eval "$3=no"
+-fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+-fi
+-eval ac_res=\$$3
+-	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+-$as_echo "$ac_res" >&6; }
+-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+-
+-} # ac_fn_cxx_check_header_compile
+-
+ # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
+ # ----------------------------------------------
+ # Tries to find the compile-time value of EXPR in a program that includes
+@@ -2561,7 +2521,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ $4
+ int
+-main ()
++main (void)
+ {
+ static int test_array [1 - 2 * !(($2) >= 0)];
+ test_array [0] = 0;
+@@ -2571,14 +2531,15 @@ return test_array [0];
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+   ac_lo=0 ac_mid=0
+   while :; do
+     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ $4
+ int
+-main ()
++main (void)
+ {
+ static int test_array [1 - 2 * !(($2) <= $ac_mid)];
+ test_array [0] = 0;
+@@ -2588,24 +2549,26 @@ return test_array [0];
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+   ac_hi=$ac_mid; break
+-else
+-  as_fn_arith $ac_mid + 1 && ac_lo=$as_val
++else case e in #(
++  e) as_fn_arith $ac_mid + 1 && ac_lo=$as_val
+ 			if test $ac_lo -le $ac_mid; then
+ 			  ac_lo= ac_hi=
+ 			  break
+ 			fi
+-			as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
++			as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   done
+-else
+-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++else case e in #(
++  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ $4
+ int
+-main ()
++main (void)
+ {
+ static int test_array [1 - 2 * !(($2) < 0)];
+ test_array [0] = 0;
+@@ -2615,14 +2578,15 @@ return test_array [0];
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+   ac_hi=-1 ac_mid=-1
+   while :; do
+     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ $4
+ int
+-main ()
++main (void)
+ {
+ static int test_array [1 - 2 * !(($2) >= $ac_mid)];
+ test_array [0] = 0;
+@@ -2632,24 +2596,28 @@ return test_array [0];
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+   ac_lo=$ac_mid; break
+-else
+-  as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
++else case e in #(
++  e) as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
+ 			if test $ac_mid -le $ac_hi; then
+ 			  ac_lo= ac_hi=
+ 			  break
+ 			fi
+-			as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
++			as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   done
+-else
+-  ac_lo= ac_hi=
++else case e in #(
++  e) ac_lo= ac_hi= ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+ # Binary search between lo and hi bounds.
+ while test "x$ac_lo" != "x$ac_hi"; do
+   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
+@@ -2657,7 +2625,7 @@ while test "x$ac_lo" != "x$ac_hi"; do
+ /* end confdefs.h.  */
+ $4
+ int
+-main ()
++main (void)
+ {
+ static int test_array [1 - 2 * !(($2) <= $ac_mid)];
+ test_array [0] = 0;
+@@ -2667,12 +2635,14 @@ return test_array [0];
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+   ac_hi=$ac_mid
+-else
+-  as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
++else case e in #(
++  e) as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+ done
+ case $ac_lo in #((
+ ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
+@@ -2682,12 +2652,12 @@ esac
+     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ $4
+-static long int longval () { return $2; }
+-static unsigned long int ulongval () { return $2; }
++static long int longval (void) { return $2; }
++static unsigned long int ulongval (void) { return $2; }
+ #include <stdio.h>
+ #include <stdlib.h>
+ int
+-main ()
++main (void)
+ {
+ 
+   FILE *f = fopen ("conftest.val", "w");
+@@ -2715,10 +2685,12 @@ main ()
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_run "$LINENO"; then :
++if ac_fn_cxx_try_run "$LINENO"
++then :
+   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
+-else
+-  ac_retval=1
++else case e in #(
++  e) ac_retval=1 ;;
++esac
+ fi
+ rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+   conftest.$ac_objext conftest.beam conftest.$ac_ext
+@@ -2736,14 +2708,14 @@ rm -f conftest.val
+ ac_fn_cxx_try_link ()
+ {
+   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+-  rm -f conftest.$ac_objext conftest$ac_exeext
++  rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext
+   if { { ac_try="$ac_link"
+ case "(($ac_try" in
+   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_link") 2>conftest.err
+   ac_status=$?
+   if test -s conftest.err; then
+@@ -2751,20 +2723,22 @@ $as_echo "$ac_try_echo"; } >&5
+     cat conftest.er1 >&5
+     mv -f conftest.er1 conftest.err
+   fi
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; } && {
+ 	 test -z "$ac_cxx_werror_flag" ||
+ 	 test ! -s conftest.err
+        } && test -s conftest$ac_exeext && {
+ 	 test "$cross_compiling" = yes ||
+ 	 test -x conftest$ac_exeext
+-       }; then :
++       }
++then :
+   ac_retval=0
+-else
+-  $as_echo "$as_me: failed program was:" >&5
++else case e in #(
++  e) printf "%s\n" "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+ 
+-	ac_retval=1
++	ac_retval=1 ;;
++esac
+ fi
+   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+@@ -2782,28 +2756,22 @@ fi
+ ac_fn_cxx_check_func ()
+ {
+   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+-$as_echo_n "checking for $2... " >&6; }
+-if eval \${$3+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
++printf %s "checking for $2... " >&6; }
++if eval test \${$3+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
+    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+ #define $2 innocuous_$2
+ 
+ /* System header to define __stub macros and hopefully few prototypes,
+-    which can conflict with char $2 (); below.
+-    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+-    <limits.h> exists even on freestanding compilers.  */
+-
+-#ifdef __STDC__
+-# include <limits.h>
+-#else
+-# include <assert.h>
+-#endif
++   which can conflict with char $2 (void); below.  */
+ 
++#include <limits.h>
+ #undef $2
+ 
+ /* Override any GCC internal prototype to avoid an error.
+@@ -2812,7 +2780,7 @@ else
+ #ifdef __cplusplus
+ extern "C"
+ #endif
+-char $2 ();
++char $2 (void);
+ /* The GNU C library defines this for functions which it implements
+     to always fail with ENOSYS.  Some functions are actually named
+     something starting with __ and the normal name is an alias.  */
+@@ -2821,24 +2789,27 @@ choke me
+ #endif
+ 
+ int
+-main ()
++main (void)
+ {
+ return $2 ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   eval "$3=yes"
+-else
+-  eval "$3=no"
++else case e in #(
++  e) eval "$3=no" ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
+-    conftest$ac_exeext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
++    conftest$ac_exeext conftest.$ac_ext ;;
++esac
+ fi
+ eval ac_res=\$$3
+-	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+-$as_echo "$ac_res" >&6; }
++	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
++printf "%s\n" "$ac_res" >&6; }
+   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+ 
+ } # ac_fn_cxx_check_func
+@@ -2850,37 +2821,61 @@ $as_echo "$ac_res" >&6; }
+ ac_fn_c_check_header_compile ()
+ {
+   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+-$as_echo_n "checking for $2... " >&6; }
+-if eval \${$3+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
++printf %s "checking for $2... " >&6; }
++if eval test \${$3+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ $4
+ #include <$2>
+ _ACEOF
+-if ac_fn_c_try_compile "$LINENO"; then :
++if ac_fn_c_try_compile "$LINENO"
++then :
+   eval "$3=yes"
+-else
+-  eval "$3=no"
++else case e in #(
++  e) eval "$3=no" ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
++esac
+ fi
+ eval ac_res=\$$3
+-	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+-$as_echo "$ac_res" >&6; }
++	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
++printf "%s\n" "$ac_res" >&6; }
+   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+ 
+ } # ac_fn_c_check_header_compile
++ac_configure_args_raw=
++for ac_arg
++do
++  case $ac_arg in
++  *\'*)
++    ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
++  esac
++  as_fn_append ac_configure_args_raw " '$ac_arg'"
++done
++
++case $ac_configure_args_raw in
++  *$as_nl*)
++    ac_safe_unquote= ;;
++  *)
++    ac_unsafe_z='|&;<>()$`\\"*?[ ''	' # This string ends in space, tab.
++    ac_unsafe_a="$ac_unsafe_z#~"
++    ac_safe_unquote="s/ '\\([^$ac_unsafe_a][^$ac_unsafe_z]*\\)'/ \\1/g"
++    ac_configure_args_raw=`      printf "%s\n" "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;;
++esac
++
+ cat >config.log <<_ACEOF
+ This file contains any messages produced by compilers while
+ running configure, to aid debugging if configure makes a mistake.
+ 
+ It was created by OpenJDK $as_me jdk8, which was
+-generated by GNU Autoconf 2.69.  Invocation command line was
++generated by GNU Autoconf 2.72.  Invocation command line was
+ 
+-  $ $0 $@
++  $ $0$ac_configure_args_raw
+ 
+ _ACEOF
+ exec 5>>config.log
+@@ -2913,8 +2908,12 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-    $as_echo "PATH: $as_dir"
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
++    printf "%s\n" "PATH: $as_dir"
+   done
+ IFS=$as_save_IFS
+ 
+@@ -2949,7 +2948,7 @@ do
+     | -silent | --silent | --silen | --sile | --sil)
+       continue ;;
+     *\'*)
+-      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
++      ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+     esac
+     case $ac_pass in
+     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
+@@ -2984,11 +2983,13 @@ done
+ # WARNING: Use '\'' to represent an apostrophe within the trap.
+ # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+ trap 'exit_status=$?
++  # Sanitize IFS.
++  IFS=" ""	$as_nl"
+   # Save into config.log some information that might help in debugging.
+   {
+     echo
+ 
+-    $as_echo "## ---------------- ##
++    printf "%s\n" "## ---------------- ##
+ ## Cache variables. ##
+ ## ---------------- ##"
+     echo
+@@ -2999,8 +3000,8 @@ trap 'exit_status=$?
+     case $ac_val in #(
+     *${as_nl}*)
+       case $ac_var in #(
+-      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+-$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
++      *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
++printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+       esac
+       case $ac_var in #(
+       _ | IFS | as_nl) ;; #(
+@@ -3024,7 +3025,7 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+ )
+     echo
+ 
+-    $as_echo "## ----------------- ##
++    printf "%s\n" "## ----------------- ##
+ ## Output variables. ##
+ ## ----------------- ##"
+     echo
+@@ -3032,14 +3033,14 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+     do
+       eval ac_val=\$$ac_var
+       case $ac_val in
+-      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
++      *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+       esac
+-      $as_echo "$ac_var='\''$ac_val'\''"
++      printf "%s\n" "$ac_var='\''$ac_val'\''"
+     done | sort
+     echo
+ 
+     if test -n "$ac_subst_files"; then
+-      $as_echo "## ------------------- ##
++      printf "%s\n" "## ------------------- ##
+ ## File substitutions. ##
+ ## ------------------- ##"
+       echo
+@@ -3047,15 +3048,15 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+       do
+ 	eval ac_val=\$$ac_var
+ 	case $ac_val in
+-	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
++	*\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+ 	esac
+-	$as_echo "$ac_var='\''$ac_val'\''"
++	printf "%s\n" "$ac_var='\''$ac_val'\''"
+       done | sort
+       echo
+     fi
+ 
+     if test -s confdefs.h; then
+-      $as_echo "## ----------- ##
++      printf "%s\n" "## ----------- ##
+ ## confdefs.h. ##
+ ## ----------- ##"
+       echo
+@@ -3063,8 +3064,8 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+       echo
+     fi
+     test "$ac_signal" != 0 &&
+-      $as_echo "$as_me: caught signal $ac_signal"
+-    $as_echo "$as_me: exit $exit_status"
++      printf "%s\n" "$as_me: caught signal $ac_signal"
++    printf "%s\n" "$as_me: exit $exit_status"
+   } >&5
+   rm -f core *.core core.conftest.* &&
+     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+@@ -3078,65 +3079,50 @@ ac_signal=0
+ # confdefs.h avoids OS command line length limits that DEFS can exceed.
+ rm -f -r conftest* confdefs.h
+ 
+-$as_echo "/* confdefs.h */" > confdefs.h
++printf "%s\n" "/* confdefs.h */" > confdefs.h
+ 
+ # Predefined preprocessor variables.
+ 
+-cat >>confdefs.h <<_ACEOF
+-#define PACKAGE_NAME "$PACKAGE_NAME"
+-_ACEOF
++printf "%s\n" "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h
+ 
+-cat >>confdefs.h <<_ACEOF
+-#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+-_ACEOF
++printf "%s\n" "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h
+ 
+-cat >>confdefs.h <<_ACEOF
+-#define PACKAGE_VERSION "$PACKAGE_VERSION"
+-_ACEOF
++printf "%s\n" "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h
+ 
+-cat >>confdefs.h <<_ACEOF
+-#define PACKAGE_STRING "$PACKAGE_STRING"
+-_ACEOF
++printf "%s\n" "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h
+ 
+-cat >>confdefs.h <<_ACEOF
+-#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+-_ACEOF
++printf "%s\n" "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h
+ 
+-cat >>confdefs.h <<_ACEOF
+-#define PACKAGE_URL "$PACKAGE_URL"
+-_ACEOF
++printf "%s\n" "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h
+ 
+ 
+ # Let the site file select an alternate cache file if it wants to.
+ # Prefer an explicitly selected file to automatically selected ones.
+-ac_site_file1=NONE
+-ac_site_file2=NONE
+ if test -n "$CONFIG_SITE"; then
+-  # We do not want a PATH search for config.site.
+-  case $CONFIG_SITE in #((
+-    -*)  ac_site_file1=./$CONFIG_SITE;;
+-    */*) ac_site_file1=$CONFIG_SITE;;
+-    *)   ac_site_file1=./$CONFIG_SITE;;
+-  esac
++  ac_site_files="$CONFIG_SITE"
+ elif test "x$prefix" != xNONE; then
+-  ac_site_file1=$prefix/share/config.site
+-  ac_site_file2=$prefix/etc/config.site
++  ac_site_files="$prefix/share/config.site $prefix/etc/config.site"
+ else
+-  ac_site_file1=$ac_default_prefix/share/config.site
+-  ac_site_file2=$ac_default_prefix/etc/config.site
++  ac_site_files="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
+ fi
+-for ac_site_file in "$ac_site_file1" "$ac_site_file2"
++
++for ac_site_file in $ac_site_files
+ do
+-  test "x$ac_site_file" = xNONE && continue
+-  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
+-$as_echo "$as_me: loading site script $ac_site_file" >&6;}
++  case $ac_site_file in #(
++  */*) :
++     ;; #(
++  *) :
++    ac_site_file=./$ac_site_file ;;
++esac
++  if test -f "$ac_site_file" && test -r "$ac_site_file"; then
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
++printf "%s\n" "$as_me: loading site script $ac_site_file" >&6;}
+     sed 's/^/| /' "$ac_site_file" >&5
+     . "$ac_site_file" \
+-      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
++      || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
++printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ as_fn_error $? "failed to load site script $ac_site_file
+-See \`config.log' for more details" "$LINENO" 5; }
++See 'config.log' for more details" "$LINENO" 5; }
+   fi
+ done
+ 
+@@ -3144,19 +3130,668 @@ if test -r "$cache_file"; then
+   # Some versions of bash will fail to source /dev/null (special files
+   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
+   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
+-$as_echo "$as_me: loading cache $cache_file" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
++printf "%s\n" "$as_me: loading cache $cache_file" >&6;}
+     case $cache_file in
+       [\\/]* | ?:[\\/]* ) . "$cache_file";;
+       *)                      . "./$cache_file";;
+     esac
+   fi
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
+-$as_echo "$as_me: creating cache $cache_file" >&6;}
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
++printf "%s\n" "$as_me: creating cache $cache_file" >&6;}
+   >$cache_file
+ fi
+ 
++# Test code for whether the C compiler supports C89 (global declarations)
++ac_c_conftest_c89_globals='
++/* Does the compiler advertise C89 conformance?
++   Do not test the value of __STDC__, because some compilers set it to 0
++   while being otherwise adequately conformant. */
++#if !defined __STDC__
++# error "Compiler does not advertise C89 conformance"
++#endif
++
++#include <stddef.h>
++#include <stdarg.h>
++struct stat;
++/* Most of the following tests are stolen from RCS 5.7 src/conf.sh.  */
++struct buf { int x; };
++struct buf * (*rcsopen) (struct buf *, struct stat *, int);
++static char *e (char **p, int i)
++{
++  return p[i];
++}
++static char *f (char * (*g) (char **, int), char **p, ...)
++{
++  char *s;
++  va_list v;
++  va_start (v,p);
++  s = g (p, va_arg (v,int));
++  va_end (v);
++  return s;
++}
++
++/* C89 style stringification. */
++#define noexpand_stringify(a) #a
++const char *stringified = noexpand_stringify(arbitrary+token=sequence);
++
++/* C89 style token pasting.  Exercises some of the corner cases that
++   e.g. old MSVC gets wrong, but not very hard. */
++#define noexpand_concat(a,b) a##b
++#define expand_concat(a,b) noexpand_concat(a,b)
++extern int vA;
++extern int vbee;
++#define aye A
++#define bee B
++int *pvA = &expand_concat(v,aye);
++int *pvbee = &noexpand_concat(v,bee);
++
++/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
++   function prototypes and stuff, but not \xHH hex character constants.
++   These do not provoke an error unfortunately, instead are silently treated
++   as an "x".  The following induces an error, until -std is added to get
++   proper ANSI mode.  Curiously \x00 != x always comes out true, for an
++   array size at least.  It is necessary to write \x00 == 0 to get something
++   that is true only with -std.  */
++int osf4_cc_array ['\''\x00'\'' == 0 ? 1 : -1];
++
++/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
++   inside strings and character constants.  */
++#define FOO(x) '\''x'\''
++int xlc6_cc_array[FOO(a) == '\''x'\'' ? 1 : -1];
++
++int test (int i, double x);
++struct s1 {int (*f) (int a);};
++struct s2 {int (*f) (double a);};
++int pairnames (int, char **, int *(*)(struct buf *, struct stat *, int),
++               int, int);'
++
++# Test code for whether the C compiler supports C89 (body of main).
++ac_c_conftest_c89_main='
++ok |= (argc == 0 || f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]);
++'
++
++# Test code for whether the C compiler supports C99 (global declarations)
++ac_c_conftest_c99_globals='
++/* Does the compiler advertise C99 conformance? */
++#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
++# error "Compiler does not advertise C99 conformance"
++#endif
++
++// See if C++-style comments work.
++
++#include <stdbool.h>
++extern int puts (const char *);
++extern int printf (const char *, ...);
++extern int dprintf (int, const char *, ...);
++extern void *malloc (size_t);
++extern void free (void *);
++
++// Check varargs macros.  These examples are taken from C99 6.10.3.5.
++// dprintf is used instead of fprintf to avoid needing to declare
++// FILE and stderr.
++#define debug(...) dprintf (2, __VA_ARGS__)
++#define showlist(...) puts (#__VA_ARGS__)
++#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
++static void
++test_varargs_macros (void)
++{
++  int x = 1234;
++  int y = 5678;
++  debug ("Flag");
++  debug ("X = %d\n", x);
++  showlist (The first, second, and third items.);
++  report (x>y, "x is %d but y is %d", x, y);
++}
++
++// Check long long types.
++#define BIG64 18446744073709551615ull
++#define BIG32 4294967295ul
++#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
++#if !BIG_OK
++  #error "your preprocessor is broken"
++#endif
++#if BIG_OK
++#else
++  #error "your preprocessor is broken"
++#endif
++static long long int bignum = -9223372036854775807LL;
++static unsigned long long int ubignum = BIG64;
++
++struct incomplete_array
++{
++  int datasize;
++  double data[];
++};
++
++struct named_init {
++  int number;
++  const wchar_t *name;
++  double average;
++};
++
++typedef const char *ccp;
++
++static inline int
++test_restrict (ccp restrict text)
++{
++  // Iterate through items via the restricted pointer.
++  // Also check for declarations in for loops.
++  for (unsigned int i = 0; *(text+i) != '\''\0'\''; ++i)
++    continue;
++  return 0;
++}
++
++// Check varargs and va_copy.
++static bool
++test_varargs (const char *format, ...)
++{
++  va_list args;
++  va_start (args, format);
++  va_list args_copy;
++  va_copy (args_copy, args);
++
++  const char *str = "";
++  int number = 0;
++  float fnumber = 0;
++
++  while (*format)
++    {
++      switch (*format++)
++	{
++	case '\''s'\'': // string
++	  str = va_arg (args_copy, const char *);
++	  break;
++	case '\''d'\'': // int
++	  number = va_arg (args_copy, int);
++	  break;
++	case '\''f'\'': // float
++	  fnumber = va_arg (args_copy, double);
++	  break;
++	default:
++	  break;
++	}
++    }
++  va_end (args_copy);
++  va_end (args);
++
++  return *str && number && fnumber;
++}
++'
++
++# Test code for whether the C compiler supports C99 (body of main).
++ac_c_conftest_c99_main='
++  // Check bool.
++  _Bool success = false;
++  success |= (argc != 0);
++
++  // Check restrict.
++  if (test_restrict ("String literal") == 0)
++    success = true;
++  char *restrict newvar = "Another string";
++
++  // Check varargs.
++  success &= test_varargs ("s, d'\'' f .", "string", 65, 34.234);
++  test_varargs_macros ();
++
++  // Check flexible array members.
++  struct incomplete_array *ia =
++    malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
++  ia->datasize = 10;
++  for (int i = 0; i < ia->datasize; ++i)
++    ia->data[i] = i * 1.234;
++  // Work around memory leak warnings.
++  free (ia);
++
++  // Check named initializers.
++  struct named_init ni = {
++    .number = 34,
++    .name = L"Test wide string",
++    .average = 543.34343,
++  };
++
++  ni.number = 58;
++
++  int dynamic_array[ni.number];
++  dynamic_array[0] = argv[0][0];
++  dynamic_array[ni.number - 1] = 543;
++
++  // work around unused variable warnings
++  ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\''x'\''
++	 || dynamic_array[ni.number - 1] != 543);
++'
++
++# Test code for whether the C compiler supports C11 (global declarations)
++ac_c_conftest_c11_globals='
++/* Does the compiler advertise C11 conformance? */
++#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112L
++# error "Compiler does not advertise C11 conformance"
++#endif
++
++// Check _Alignas.
++char _Alignas (double) aligned_as_double;
++char _Alignas (0) no_special_alignment;
++extern char aligned_as_int;
++char _Alignas (0) _Alignas (int) aligned_as_int;
++
++// Check _Alignof.
++enum
++{
++  int_alignment = _Alignof (int),
++  int_array_alignment = _Alignof (int[100]),
++  char_alignment = _Alignof (char)
++};
++_Static_assert (0 < -_Alignof (int), "_Alignof is signed");
++
++// Check _Noreturn.
++int _Noreturn does_not_return (void) { for (;;) continue; }
++
++// Check _Static_assert.
++struct test_static_assert
++{
++  int x;
++  _Static_assert (sizeof (int) <= sizeof (long int),
++                  "_Static_assert does not work in struct");
++  long int y;
++};
++
++// Check UTF-8 literals.
++#define u8 syntax error!
++char const utf8_literal[] = u8"happens to be ASCII" "another string";
++
++// Check duplicate typedefs.
++typedef long *long_ptr;
++typedef long int *long_ptr;
++typedef long_ptr long_ptr;
++
++// Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1.
++struct anonymous
++{
++  union {
++    struct { int i; int j; };
++    struct { int k; long int l; } w;
++  };
++  int m;
++} v1;
++'
++
++# Test code for whether the C compiler supports C11 (body of main).
++ac_c_conftest_c11_main='
++  _Static_assert ((offsetof (struct anonymous, i)
++		   == offsetof (struct anonymous, w.k)),
++		  "Anonymous union alignment botch");
++  v1.i = 2;
++  v1.w.k = 5;
++  ok |= v1.i != 5;
++'
++
++# Test code for whether the C compiler supports C11 (complete).
++ac_c_conftest_c11_program="${ac_c_conftest_c89_globals}
++${ac_c_conftest_c99_globals}
++${ac_c_conftest_c11_globals}
++
++int
++main (int argc, char **argv)
++{
++  int ok = 0;
++  ${ac_c_conftest_c89_main}
++  ${ac_c_conftest_c99_main}
++  ${ac_c_conftest_c11_main}
++  return ok;
++}
++"
++
++# Test code for whether the C compiler supports C99 (complete).
++ac_c_conftest_c99_program="${ac_c_conftest_c89_globals}
++${ac_c_conftest_c99_globals}
++
++int
++main (int argc, char **argv)
++{
++  int ok = 0;
++  ${ac_c_conftest_c89_main}
++  ${ac_c_conftest_c99_main}
++  return ok;
++}
++"
++
++# Test code for whether the C compiler supports C89 (complete).
++ac_c_conftest_c89_program="${ac_c_conftest_c89_globals}
++
++int
++main (int argc, char **argv)
++{
++  int ok = 0;
++  ${ac_c_conftest_c89_main}
++  return ok;
++}
++"
++
++# Test code for whether the C++ compiler supports C++98 (global declarations)
++ac_cxx_conftest_cxx98_globals='
++// Does the compiler advertise C++98 conformance?
++#if !defined __cplusplus || __cplusplus < 199711L
++# error "Compiler does not advertise C++98 conformance"
++#endif
++
++// These inclusions are to reject old compilers that
++// lack the unsuffixed header files.
++#include <cstdlib>
++#include <exception>
++
++// <cassert> and <cstring> are *not* freestanding headers in C++98.
++extern void assert (int);
++namespace std {
++  extern int strcmp (const char *, const char *);
++}
++
++// Namespaces, exceptions, and templates were all added after "C++ 2.0".
++using std::exception;
++using std::strcmp;
++
++namespace {
++
++void test_exception_syntax()
++{
++  try {
++    throw "test";
++  } catch (const char *s) {
++    // Extra parentheses suppress a warning when building autoconf itself,
++    // due to lint rules shared with more typical C programs.
++    assert (!(strcmp) (s, "test"));
++  }
++}
++
++template <typename T> struct test_template
++{
++  T const val;
++  explicit test_template(T t) : val(t) {}
++  template <typename U> T add(U u) { return static_cast<T>(u) + val; }
++};
++
++} // anonymous namespace
++'
++
++# Test code for whether the C++ compiler supports C++98 (body of main)
++ac_cxx_conftest_cxx98_main='
++  assert (argc);
++  assert (! argv[0]);
++{
++  test_exception_syntax ();
++  test_template<double> tt (2.0);
++  assert (tt.add (4) == 6.0);
++  assert (true && !false);
++}
++'
++
++# Test code for whether the C++ compiler supports C++11 (global declarations)
++ac_cxx_conftest_cxx11_globals='
++// Does the compiler advertise C++ 2011 conformance?
++#if !defined __cplusplus || __cplusplus < 201103L
++# error "Compiler does not advertise C++11 conformance"
++#endif
++
++namespace cxx11test
++{
++  constexpr int get_val() { return 20; }
++
++  struct testinit
++  {
++    int i;
++    double d;
++  };
++
++  class delegate
++  {
++  public:
++    delegate(int n) : n(n) {}
++    delegate(): delegate(2354) {}
++
++    virtual int getval() { return this->n; };
++  protected:
++    int n;
++  };
++
++  class overridden : public delegate
++  {
++  public:
++    overridden(int n): delegate(n) {}
++    virtual int getval() override final { return this->n * 2; }
++  };
++
++  class nocopy
++  {
++  public:
++    nocopy(int i): i(i) {}
++    nocopy() = default;
++    nocopy(const nocopy&) = delete;
++    nocopy & operator=(const nocopy&) = delete;
++  private:
++    int i;
++  };
++
++  // for testing lambda expressions
++  template <typename Ret, typename Fn> Ret eval(Fn f, Ret v)
++  {
++    return f(v);
++  }
++
++  // for testing variadic templates and trailing return types
++  template <typename V> auto sum(V first) -> V
++  {
++    return first;
++  }
++  template <typename V, typename... Args> auto sum(V first, Args... rest) -> V
++  {
++    return first + sum(rest...);
++  }
++}
++'
++
++# Test code for whether the C++ compiler supports C++11 (body of main)
++ac_cxx_conftest_cxx11_main='
++{
++  // Test auto and decltype
++  auto a1 = 6538;
++  auto a2 = 48573953.4;
++  auto a3 = "String literal";
++
++  int total = 0;
++  for (auto i = a3; *i; ++i) { total += *i; }
++
++  decltype(a2) a4 = 34895.034;
++}
++{
++  // Test constexpr
++  short sa[cxx11test::get_val()] = { 0 };
++}
++{
++  // Test initializer lists
++  cxx11test::testinit il = { 4323, 435234.23544 };
++}
++{
++  // Test range-based for
++  int array[] = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3,
++                 14, 19, 17, 8, 6, 20, 16, 2, 11, 1};
++  for (auto &x : array) { x += 23; }
++}
++{
++  // Test lambda expressions
++  using cxx11test::eval;
++  assert (eval ([](int x) { return x*2; }, 21) == 42);
++  double d = 2.0;
++  assert (eval ([&](double x) { return d += x; }, 3.0) == 5.0);
++  assert (d == 5.0);
++  assert (eval ([=](double x) mutable { return d += x; }, 4.0) == 9.0);
++  assert (d == 5.0);
++}
++{
++  // Test use of variadic templates
++  using cxx11test::sum;
++  auto a = sum(1);
++  auto b = sum(1, 2);
++  auto c = sum(1.0, 2.0, 3.0);
++}
++{
++  // Test constructor delegation
++  cxx11test::delegate d1;
++  cxx11test::delegate d2();
++  cxx11test::delegate d3(45);
++}
++{
++  // Test override and final
++  cxx11test::overridden o1(55464);
++}
++{
++  // Test nullptr
++  char *c = nullptr;
++}
++{
++  // Test template brackets
++  test_template<::test_template<int>> v(test_template<int>(12));
++}
++{
++  // Unicode literals
++  char const *utf8 = u8"UTF-8 string \u2500";
++  char16_t const *utf16 = u"UTF-8 string \u2500";
++  char32_t const *utf32 = U"UTF-32 string \u2500";
++}
++'
++
++# Test code for whether the C compiler supports C++11 (complete).
++ac_cxx_conftest_cxx11_program="${ac_cxx_conftest_cxx98_globals}
++${ac_cxx_conftest_cxx11_globals}
++
++int
++main (int argc, char **argv)
++{
++  int ok = 0;
++  ${ac_cxx_conftest_cxx98_main}
++  ${ac_cxx_conftest_cxx11_main}
++  return ok;
++}
++"
++
++# Test code for whether the C compiler supports C++98 (complete).
++ac_cxx_conftest_cxx98_program="${ac_cxx_conftest_cxx98_globals}
++int
++main (int argc, char **argv)
++{
++  int ok = 0;
++  ${ac_cxx_conftest_cxx98_main}
++  return ok;
++}
++"
++
++as_fn_append ac_header_cxx_list " stdio.h stdio_h HAVE_STDIO_H"
++as_fn_append ac_header_cxx_list " stdlib.h stdlib_h HAVE_STDLIB_H"
++as_fn_append ac_header_cxx_list " string.h string_h HAVE_STRING_H"
++as_fn_append ac_header_cxx_list " inttypes.h inttypes_h HAVE_INTTYPES_H"
++as_fn_append ac_header_cxx_list " stdint.h stdint_h HAVE_STDINT_H"
++as_fn_append ac_header_cxx_list " strings.h strings_h HAVE_STRINGS_H"
++as_fn_append ac_header_cxx_list " sys/stat.h sys_stat_h HAVE_SYS_STAT_H"
++as_fn_append ac_header_cxx_list " sys/types.h sys_types_h HAVE_SYS_TYPES_H"
++as_fn_append ac_header_cxx_list " unistd.h unistd_h HAVE_UNISTD_H"
++
++# Auxiliary files required by this configure script.
++ac_aux_files="config.guess config.sub"
++
++# Locations in which to look for auxiliary files.
++ac_aux_dir_candidates="$TOPDIR/common/autoconf/build-aux"
++
++# Search for a directory containing all of the required auxiliary files,
++# $ac_aux_files, from the $PATH-style list $ac_aux_dir_candidates.
++# If we don't find one directory that contains all the files we need,
++# we report the set of missing files from the *first* directory in
++# $ac_aux_dir_candidates and give up.
++ac_missing_aux_files=""
++ac_first_candidate=:
++printf "%s\n" "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5
++as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
++as_found=false
++for as_dir in $ac_aux_dir_candidates
++do
++  IFS=$as_save_IFS
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
++  as_found=:
++
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}:  trying $as_dir" >&5
++  ac_aux_dir_found=yes
++  ac_install_sh=
++  for ac_aux in $ac_aux_files
++  do
++    # As a special case, if "install-sh" is required, that requirement
++    # can be satisfied by any of "install-sh", "install.sh", or "shtool",
++    # and $ac_install_sh is set appropriately for whichever one is found.
++    if test x"$ac_aux" = x"install-sh"
++    then
++      if test -f "${as_dir}install-sh"; then
++        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}install-sh found" >&5
++        ac_install_sh="${as_dir}install-sh -c"
++      elif test -f "${as_dir}install.sh"; then
++        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}install.sh found" >&5
++        ac_install_sh="${as_dir}install.sh -c"
++      elif test -f "${as_dir}shtool"; then
++        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}shtool found" >&5
++        ac_install_sh="${as_dir}shtool install -c"
++      else
++        ac_aux_dir_found=no
++        if $ac_first_candidate; then
++          ac_missing_aux_files="${ac_missing_aux_files} install-sh"
++        else
++          break
++        fi
++      fi
++    else
++      if test -f "${as_dir}${ac_aux}"; then
++        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}${ac_aux} found" >&5
++      else
++        ac_aux_dir_found=no
++        if $ac_first_candidate; then
++          ac_missing_aux_files="${ac_missing_aux_files} ${ac_aux}"
++        else
++          break
++        fi
++      fi
++    fi
++  done
++  if test "$ac_aux_dir_found" = yes; then
++    ac_aux_dir="$as_dir"
++    break
++  fi
++  ac_first_candidate=false
++
++  as_found=false
++done
++IFS=$as_save_IFS
++if $as_found
++then :
++
++else case e in #(
++  e) as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5 ;;
++esac
++fi
++
++
++# These three variables are undocumented and unsupported,
++# and are intended to be withdrawn in a future Autoconf release.
++# They can cause serious problems if a builder's source tree is in a directory
++# whose full name contains unusual characters.
++if test -f "${ac_aux_dir}config.guess"; then
++  ac_config_guess="$SHELL ${ac_aux_dir}config.guess"
++fi
++if test -f "${ac_aux_dir}config.sub"; then
++  ac_config_sub="$SHELL ${ac_aux_dir}config.sub"
++fi
++if test -f "$ac_aux_dir/configure"; then
++  ac_configure="$SHELL ${ac_aux_dir}configure"
++fi
++
+ # Check that the precious variables saved in the cache have kept the same
+ # value.
+ ac_cache_corrupted=false
+@@ -3167,12 +3802,12 @@ for ac_var in $ac_precious_vars; do
+   eval ac_new_val=\$ac_env_${ac_var}_value
+   case $ac_old_set,$ac_new_set in
+     set,)
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+-$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&5
++printf "%s\n" "$as_me: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&2;}
+       ac_cache_corrupted=: ;;
+     ,set)
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
+-$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was not set in the previous run" >&5
++printf "%s\n" "$as_me: error: '$ac_var' was not set in the previous run" >&2;}
+       ac_cache_corrupted=: ;;
+     ,);;
+     *)
+@@ -3181,24 +3816,24 @@ $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+ 	ac_old_val_w=`echo x $ac_old_val`
+ 	ac_new_val_w=`echo x $ac_new_val`
+ 	if test "$ac_old_val_w" != "$ac_new_val_w"; then
+-	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
+-$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
++	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' has changed since the previous run:" >&5
++printf "%s\n" "$as_me: error: '$ac_var' has changed since the previous run:" >&2;}
+ 	  ac_cache_corrupted=:
+ 	else
+-	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
+-$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
++	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&5
++printf "%s\n" "$as_me: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&2;}
+ 	  eval $ac_var=\$ac_old_val
+ 	fi
+-	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
+-$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
+-	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
+-$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
++	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}:   former value:  '$ac_old_val'" >&5
++printf "%s\n" "$as_me:   former value:  '$ac_old_val'" >&2;}
++	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}:   current value: '$ac_new_val'" >&5
++printf "%s\n" "$as_me:   current value: '$ac_new_val'" >&2;}
+       fi;;
+   esac
+   # Pass precious variables to config.status.
+   if test "$ac_new_set" = set; then
+     case $ac_new_val in
+-    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
++    *\'*) ac_arg=$ac_var=`printf "%s\n" "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+     *) ac_arg=$ac_var=$ac_new_val ;;
+     esac
+     case " $ac_configure_args " in
+@@ -3208,11 +3843,12 @@ $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
+   fi
+ done
+ if $ac_cache_corrupted; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
+-$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+-  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
++printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
++printf "%s\n" "$as_me: error: changes in the environment can compromise the build" >&2;}
++  as_fn_error $? "run '${MAKE-make} distclean' and/or 'rm $cache_file'
++	    and start over" "$LINENO" 5
+ fi
+ ## -------------------- ##
+ ## Main body of script. ##
+@@ -3226,34 +3862,6 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ 
+ 
+ 
+-ac_aux_dir=
+-for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
+-  if test -f "$ac_dir/install-sh"; then
+-    ac_aux_dir=$ac_dir
+-    ac_install_sh="$ac_aux_dir/install-sh -c"
+-    break
+-  elif test -f "$ac_dir/install.sh"; then
+-    ac_aux_dir=$ac_dir
+-    ac_install_sh="$ac_aux_dir/install.sh -c"
+-    break
+-  elif test -f "$ac_dir/shtool"; then
+-    ac_aux_dir=$ac_dir
+-    ac_install_sh="$ac_aux_dir/shtool install -c"
+-    break
+-  fi
+-done
+-if test -z "$ac_aux_dir"; then
+-  as_fn_error $? "cannot find install-sh, install.sh, or shtool in $TOPDIR/common/autoconf/build-aux \"$srcdir\"/$TOPDIR/common/autoconf/build-aux" "$LINENO" 5
+-fi
+-
+-# These three variables are undocumented and unsupported,
+-# and are intended to be withdrawn in a future Autoconf release.
+-# They can cause serious problems if a builder's source tree is in a directory
+-# whose full name contains unusual characters.
+-ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
+-ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
+-ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
+-
+ 
+ # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
+ 
+@@ -3972,7 +4580,8 @@ pkgadd_help() {
+ # to create them
+ 
+ # Check whether --with-custom-make-dir was given.
+-if test "${with_custom_make_dir+set}" = set; then :
++if test ${with_custom_make_dir+y}
++then :
+   withval=$with_custom_make_dir; CUSTOM_MAKE_DIR=$with_custom_make_dir
+ fi
+ 
+@@ -4061,6 +4670,11 @@ fi
+ # VAR_OS and VAR_OS_API.
+ 
+ 
++# Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
++# Converts autoconf style OS name to OpenJDK style, into
++# VAR_LIBC.
++
++
+ # Expects $host_os $host_cpu $build_os and $build_cpu
+ # and $with_target_bits to have been setup!
+ #
+@@ -4410,7 +5024,7 @@ VS_TOOLSET_SUPPORTED_2022=true
+ #CUSTOM_AUTOCONF_INCLUDE
+ 
+ # Do not change or remove the following line, it is needed for consistency checks:
+-DATE_WHEN_GENERATED=1779849897
++DATE_WHEN_GENERATED=1781625962
+ 
+ ###############################################################################
+ #
+@@ -4445,10 +5059,10 @@ DATE_WHEN_GENERATED=1779849897
+ 
+   DATE_WHEN_CONFIGURED=`LANG=C date`
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
+-$as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
+-$as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
++printf "%s\n" "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
++printf "%s\n" "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
+ 
+ 
+   # Start with tools that do not need have cross compilation support
+@@ -4470,12 +5084,13 @@ $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED."
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BASENAME+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BASENAME in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BASENAME+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BASENAME in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
+   ;;
+@@ -4484,11 +5099,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BASENAME="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -4496,15 +5115,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BASENAME=$ac_cv_path_BASENAME
+ if test -n "$BASENAME"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
+-$as_echo "$BASENAME" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
++printf "%s\n" "$BASENAME" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -4520,20 +5140,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xBASENAME" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in basename
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BASENAME+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BASENAME in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BASENAME+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BASENAME in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
+   ;;
+@@ -4542,11 +5163,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BASENAME="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -4554,15 +5179,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BASENAME=$ac_cv_path_BASENAME
+ if test -n "$BASENAME"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
+-$as_echo "$BASENAME" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
++printf "%s\n" "$BASENAME" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -4582,16 +5208,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BASENAME+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BASENAME in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BASENAME+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BASENAME in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
+   ;;
+@@ -4600,11 +5227,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BASENAME="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -4612,15 +5243,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BASENAME=$ac_cv_path_BASENAME
+ if test -n "$BASENAME"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
+-$as_echo "$BASENAME" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
++printf "%s\n" "$BASENAME" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -4629,17 +5261,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
+-$as_echo_n "checking for BASENAME... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
++printf %s "checking for BASENAME... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -4663,12 +5295,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BASH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BASH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BASH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BASH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
+   ;;
+@@ -4677,11 +5310,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BASH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -4689,15 +5326,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BASH=$ac_cv_path_BASH
+ if test -n "$BASH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
+-$as_echo "$BASH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
++printf "%s\n" "$BASH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -4713,20 +5351,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xBASH" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in bash
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BASH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BASH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BASH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BASH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
+   ;;
+@@ -4735,11 +5374,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BASH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -4747,15 +5390,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BASH=$ac_cv_path_BASH
+ if test -n "$BASH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
+-$as_echo "$BASH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
++printf "%s\n" "$BASH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -4775,16 +5419,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BASH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BASH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BASH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BASH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
+   ;;
+@@ -4793,11 +5438,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BASH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -4805,15 +5454,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BASH=$ac_cv_path_BASH
+ if test -n "$BASH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
+-$as_echo "$BASH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
++printf "%s\n" "$BASH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -4822,17 +5472,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
+-$as_echo_n "checking for BASH... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
++printf %s "checking for BASH... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -4856,12 +5506,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CAT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CAT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CAT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CAT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
+   ;;
+@@ -4870,11 +5521,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CAT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -4882,15 +5537,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CAT=$ac_cv_path_CAT
+ if test -n "$CAT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
+-$as_echo "$CAT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
++printf "%s\n" "$CAT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -4906,20 +5562,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xCAT" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in cat
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CAT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CAT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CAT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CAT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
+   ;;
+@@ -4928,11 +5585,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CAT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -4940,15 +5601,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CAT=$ac_cv_path_CAT
+ if test -n "$CAT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
+-$as_echo "$CAT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
++printf "%s\n" "$CAT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -4968,16 +5630,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CAT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CAT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CAT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CAT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
+   ;;
+@@ -4986,11 +5649,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CAT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -4998,15 +5665,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CAT=$ac_cv_path_CAT
+ if test -n "$CAT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
+-$as_echo "$CAT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
++printf "%s\n" "$CAT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5015,17 +5683,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
+-$as_echo_n "checking for CAT... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
++printf %s "checking for CAT... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -5049,12 +5717,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CHMOD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CHMOD in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CHMOD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CHMOD in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
+   ;;
+@@ -5063,11 +5732,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CHMOD="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5075,15 +5748,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CHMOD=$ac_cv_path_CHMOD
+ if test -n "$CHMOD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
+-$as_echo "$CHMOD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
++printf "%s\n" "$CHMOD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5099,20 +5773,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xCHMOD" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in chmod
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CHMOD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CHMOD in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CHMOD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CHMOD in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
+   ;;
+@@ -5121,11 +5796,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CHMOD="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5133,15 +5812,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CHMOD=$ac_cv_path_CHMOD
+ if test -n "$CHMOD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
+-$as_echo "$CHMOD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
++printf "%s\n" "$CHMOD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5161,16 +5841,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CHMOD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CHMOD in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CHMOD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CHMOD in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
+   ;;
+@@ -5179,11 +5860,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CHMOD="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5191,15 +5876,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CHMOD=$ac_cv_path_CHMOD
+ if test -n "$CHMOD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
+-$as_echo "$CHMOD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
++printf "%s\n" "$CHMOD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5208,17 +5894,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
+-$as_echo_n "checking for CHMOD... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
++printf %s "checking for CHMOD... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -5242,12 +5928,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CMP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CMP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CMP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CMP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
+   ;;
+@@ -5256,11 +5943,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CMP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5268,15 +5959,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CMP=$ac_cv_path_CMP
+ if test -n "$CMP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
+-$as_echo "$CMP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
++printf "%s\n" "$CMP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5292,20 +5984,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xCMP" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in cmp
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CMP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CMP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CMP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CMP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
+   ;;
+@@ -5314,11 +6007,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CMP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5326,15 +6023,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CMP=$ac_cv_path_CMP
+ if test -n "$CMP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
+-$as_echo "$CMP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
++printf "%s\n" "$CMP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5354,16 +6052,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CMP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CMP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CMP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CMP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
+   ;;
+@@ -5372,11 +6071,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CMP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5384,15 +6087,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CMP=$ac_cv_path_CMP
+ if test -n "$CMP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
+-$as_echo "$CMP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
++printf "%s\n" "$CMP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5401,17 +6105,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
+-$as_echo_n "checking for CMP... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
++printf %s "checking for CMP... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -5435,12 +6139,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_COMM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $COMM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_COMM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $COMM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
+   ;;
+@@ -5449,11 +6154,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_COMM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5461,15 +6170,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ COMM=$ac_cv_path_COMM
+ if test -n "$COMM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
+-$as_echo "$COMM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
++printf "%s\n" "$COMM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5485,20 +6195,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xCOMM" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in comm
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_COMM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $COMM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_COMM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $COMM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
+   ;;
+@@ -5507,11 +6218,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_COMM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5519,15 +6234,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ COMM=$ac_cv_path_COMM
+ if test -n "$COMM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
+-$as_echo "$COMM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
++printf "%s\n" "$COMM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5547,16 +6263,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_COMM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $COMM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_COMM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $COMM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
+   ;;
+@@ -5565,11 +6282,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_COMM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5577,15 +6298,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ COMM=$ac_cv_path_COMM
+ if test -n "$COMM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
+-$as_echo "$COMM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
++printf "%s\n" "$COMM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5594,17 +6316,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
+-$as_echo_n "checking for COMM... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
++printf %s "checking for COMM... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -5628,12 +6350,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CP="$CP" # Let the user override the test with a path.
+   ;;
+@@ -5642,11 +6365,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5654,15 +6381,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CP=$ac_cv_path_CP
+ if test -n "$CP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
+-$as_echo "$CP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
++printf "%s\n" "$CP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5678,20 +6406,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xCP" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in cp
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CP="$CP" # Let the user override the test with a path.
+   ;;
+@@ -5700,11 +6429,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5712,15 +6445,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CP=$ac_cv_path_CP
+ if test -n "$CP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
+-$as_echo "$CP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
++printf "%s\n" "$CP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5740,16 +6474,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CP="$CP" # Let the user override the test with a path.
+   ;;
+@@ -5758,11 +6493,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5770,15 +6509,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CP=$ac_cv_path_CP
+ if test -n "$CP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
+-$as_echo "$CP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
++printf "%s\n" "$CP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5787,17 +6527,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
+-$as_echo_n "checking for CP... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
++printf %s "checking for CP... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -5821,12 +6561,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CUT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CUT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CUT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CUT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
+   ;;
+@@ -5835,11 +6576,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CUT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5847,15 +6592,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CUT=$ac_cv_path_CUT
+ if test -n "$CUT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
+-$as_echo "$CUT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
++printf "%s\n" "$CUT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5871,20 +6617,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xCUT" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in cut
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CUT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CUT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CUT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CUT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
+   ;;
+@@ -5893,11 +6640,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CUT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5905,15 +6656,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CUT=$ac_cv_path_CUT
+ if test -n "$CUT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
+-$as_echo "$CUT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
++printf "%s\n" "$CUT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5933,16 +6685,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CUT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CUT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CUT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CUT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
+   ;;
+@@ -5951,11 +6704,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CUT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -5963,15 +6720,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CUT=$ac_cv_path_CUT
+ if test -n "$CUT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
+-$as_echo "$CUT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
++printf "%s\n" "$CUT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -5980,17 +6738,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
+-$as_echo_n "checking for CUT... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
++printf %s "checking for CUT... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -6014,12 +6772,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DATE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DATE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DATE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DATE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
+   ;;
+@@ -6028,11 +6787,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DATE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6040,15 +6803,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DATE=$ac_cv_path_DATE
+ if test -n "$DATE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
+-$as_echo "$DATE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
++printf "%s\n" "$DATE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6064,20 +6828,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xDATE" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in date
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DATE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DATE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DATE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DATE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
+   ;;
+@@ -6086,11 +6851,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DATE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6098,15 +6867,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DATE=$ac_cv_path_DATE
+ if test -n "$DATE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
+-$as_echo "$DATE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
++printf "%s\n" "$DATE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6126,16 +6896,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DATE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DATE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DATE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DATE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
+   ;;
+@@ -6144,11 +6915,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DATE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6156,15 +6931,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DATE=$ac_cv_path_DATE
+ if test -n "$DATE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
+-$as_echo "$DATE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
++printf "%s\n" "$DATE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6173,17 +6949,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
+-$as_echo_n "checking for DATE... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
++printf %s "checking for DATE... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -6207,12 +6983,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DIFF+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DIFF in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DIFF+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DIFF in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
+   ;;
+@@ -6221,11 +6998,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DIFF="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6233,15 +7014,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DIFF=$ac_cv_path_DIFF
+ if test -n "$DIFF"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
+-$as_echo "$DIFF" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
++printf "%s\n" "$DIFF" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6257,20 +7039,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xDIFF" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in gdiff diff
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DIFF+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DIFF in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DIFF+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DIFF in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
+   ;;
+@@ -6279,11 +7062,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DIFF="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6291,15 +7078,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DIFF=$ac_cv_path_DIFF
+ if test -n "$DIFF"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
+-$as_echo "$DIFF" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
++printf "%s\n" "$DIFF" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6319,16 +7107,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DIFF+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DIFF in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DIFF+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DIFF in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
+   ;;
+@@ -6337,11 +7126,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DIFF="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6349,15 +7142,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DIFF=$ac_cv_path_DIFF
+ if test -n "$DIFF"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
+-$as_echo "$DIFF" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
++printf "%s\n" "$DIFF" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6366,17 +7160,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
+-$as_echo_n "checking for DIFF... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
++printf %s "checking for DIFF... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -6400,12 +7194,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DIRNAME+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DIRNAME in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DIRNAME+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DIRNAME in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
+   ;;
+@@ -6414,11 +7209,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DIRNAME="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6426,15 +7225,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DIRNAME=$ac_cv_path_DIRNAME
+ if test -n "$DIRNAME"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
+-$as_echo "$DIRNAME" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
++printf "%s\n" "$DIRNAME" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6450,20 +7250,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xDIRNAME" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in dirname
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DIRNAME+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DIRNAME in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DIRNAME+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DIRNAME in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
+   ;;
+@@ -6472,11 +7273,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DIRNAME="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6484,15 +7289,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DIRNAME=$ac_cv_path_DIRNAME
+ if test -n "$DIRNAME"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
+-$as_echo "$DIRNAME" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
++printf "%s\n" "$DIRNAME" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6512,16 +7318,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DIRNAME+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DIRNAME in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DIRNAME+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DIRNAME in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
+   ;;
+@@ -6530,11 +7337,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DIRNAME="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6542,15 +7353,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DIRNAME=$ac_cv_path_DIRNAME
+ if test -n "$DIRNAME"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
+-$as_echo "$DIRNAME" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
++printf "%s\n" "$DIRNAME" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6559,17 +7371,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
+-$as_echo_n "checking for DIRNAME... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
++printf %s "checking for DIRNAME... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -6593,12 +7405,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_ECHO+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $ECHO in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_ECHO+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $ECHO in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
+   ;;
+@@ -6607,11 +7420,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_ECHO="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6619,15 +7436,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ ECHO=$ac_cv_path_ECHO
+ if test -n "$ECHO"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
+-$as_echo "$ECHO" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
++printf "%s\n" "$ECHO" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6643,20 +7461,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xECHO" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in echo
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_ECHO+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $ECHO in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_ECHO+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $ECHO in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
+   ;;
+@@ -6665,11 +7484,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_ECHO="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6677,15 +7500,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ ECHO=$ac_cv_path_ECHO
+ if test -n "$ECHO"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
+-$as_echo "$ECHO" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
++printf "%s\n" "$ECHO" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6705,16 +7529,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_ECHO+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $ECHO in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_ECHO+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $ECHO in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
+   ;;
+@@ -6723,11 +7548,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_ECHO="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6735,15 +7564,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ ECHO=$ac_cv_path_ECHO
+ if test -n "$ECHO"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
+-$as_echo "$ECHO" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
++printf "%s\n" "$ECHO" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6752,17 +7582,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
+-$as_echo_n "checking for ECHO... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
++printf %s "checking for ECHO... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -6786,12 +7616,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_EXPR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $EXPR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_EXPR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $EXPR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
+   ;;
+@@ -6800,11 +7631,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_EXPR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6812,15 +7647,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ EXPR=$ac_cv_path_EXPR
+ if test -n "$EXPR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
+-$as_echo "$EXPR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
++printf "%s\n" "$EXPR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6836,20 +7672,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xEXPR" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in expr
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_EXPR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $EXPR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_EXPR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $EXPR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
+   ;;
+@@ -6858,11 +7695,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_EXPR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6870,15 +7711,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ EXPR=$ac_cv_path_EXPR
+ if test -n "$EXPR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
+-$as_echo "$EXPR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
++printf "%s\n" "$EXPR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6898,16 +7740,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_EXPR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $EXPR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_EXPR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $EXPR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
+   ;;
+@@ -6916,11 +7759,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_EXPR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -6928,15 +7775,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ EXPR=$ac_cv_path_EXPR
+ if test -n "$EXPR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
+-$as_echo "$EXPR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
++printf "%s\n" "$EXPR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -6945,17 +7793,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
+-$as_echo_n "checking for EXPR... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
++printf %s "checking for EXPR... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -6979,12 +7827,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_FILE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $FILE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_FILE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $FILE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
+   ;;
+@@ -6993,11 +7842,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_FILE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7005,15 +7858,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ FILE=$ac_cv_path_FILE
+ if test -n "$FILE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
+-$as_echo "$FILE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
++printf "%s\n" "$FILE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7029,20 +7883,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xFILE" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in file
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_FILE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $FILE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_FILE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $FILE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
+   ;;
+@@ -7051,11 +7906,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_FILE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7063,15 +7922,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ FILE=$ac_cv_path_FILE
+ if test -n "$FILE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
+-$as_echo "$FILE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
++printf "%s\n" "$FILE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7091,16 +7951,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_FILE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $FILE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_FILE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $FILE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
+   ;;
+@@ -7109,11 +7970,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_FILE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7121,15 +7986,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ FILE=$ac_cv_path_FILE
+ if test -n "$FILE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
+-$as_echo "$FILE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
++printf "%s\n" "$FILE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7138,17 +8004,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
+-$as_echo_n "checking for FILE... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
++printf %s "checking for FILE... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -7172,12 +8038,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_FIND+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $FIND in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_FIND+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $FIND in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
+   ;;
+@@ -7186,11 +8053,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_FIND="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7198,15 +8069,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ FIND=$ac_cv_path_FIND
+ if test -n "$FIND"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
+-$as_echo "$FIND" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
++printf "%s\n" "$FIND" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7222,20 +8094,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xFIND" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in find
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_FIND+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $FIND in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_FIND+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $FIND in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
+   ;;
+@@ -7244,11 +8117,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_FIND="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7256,15 +8133,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ FIND=$ac_cv_path_FIND
+ if test -n "$FIND"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
+-$as_echo "$FIND" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
++printf "%s\n" "$FIND" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7284,16 +8162,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_FIND+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $FIND in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_FIND+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $FIND in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
+   ;;
+@@ -7302,11 +8181,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_FIND="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7314,15 +8197,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ FIND=$ac_cv_path_FIND
+ if test -n "$FIND"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
+-$as_echo "$FIND" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
++printf "%s\n" "$FIND" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7331,17 +8215,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
+-$as_echo_n "checking for FIND... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
++printf %s "checking for FIND... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -7365,12 +8249,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_HEAD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $HEAD in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_HEAD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $HEAD in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
+   ;;
+@@ -7379,11 +8264,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_HEAD="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7391,15 +8280,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ HEAD=$ac_cv_path_HEAD
+ if test -n "$HEAD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
+-$as_echo "$HEAD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
++printf "%s\n" "$HEAD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7415,20 +8305,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xHEAD" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in head
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_HEAD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $HEAD in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_HEAD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $HEAD in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
+   ;;
+@@ -7437,11 +8328,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_HEAD="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7449,15 +8344,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ HEAD=$ac_cv_path_HEAD
+ if test -n "$HEAD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
+-$as_echo "$HEAD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
++printf "%s\n" "$HEAD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7477,16 +8373,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_HEAD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $HEAD in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_HEAD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $HEAD in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
+   ;;
+@@ -7495,11 +8392,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_HEAD="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7507,15 +8408,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ HEAD=$ac_cv_path_HEAD
+ if test -n "$HEAD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
+-$as_echo "$HEAD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
++printf "%s\n" "$HEAD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7524,17 +8426,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
+-$as_echo_n "checking for HEAD... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
++printf %s "checking for HEAD... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -7558,12 +8460,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_LN+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $LN in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_LN+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $LN in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_LN="$LN" # Let the user override the test with a path.
+   ;;
+@@ -7572,11 +8475,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_LN="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7584,15 +8491,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ LN=$ac_cv_path_LN
+ if test -n "$LN"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
+-$as_echo "$LN" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
++printf "%s\n" "$LN" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7608,20 +8516,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xLN" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in ln
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_LN+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $LN in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_LN+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $LN in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_LN="$LN" # Let the user override the test with a path.
+   ;;
+@@ -7630,11 +8539,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_LN="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7642,15 +8555,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ LN=$ac_cv_path_LN
+ if test -n "$LN"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
+-$as_echo "$LN" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
++printf "%s\n" "$LN" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7670,16 +8584,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_LN+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $LN in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_LN+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $LN in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_LN="$LN" # Let the user override the test with a path.
+   ;;
+@@ -7688,11 +8603,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_LN="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7700,15 +8619,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ LN=$ac_cv_path_LN
+ if test -n "$LN"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
+-$as_echo "$LN" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
++printf "%s\n" "$LN" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7717,17 +8637,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
+-$as_echo_n "checking for LN... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
++printf %s "checking for LN... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -7751,12 +8671,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_LS+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $LS in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_LS+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $LS in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_LS="$LS" # Let the user override the test with a path.
+   ;;
+@@ -7765,11 +8686,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_LS="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7777,15 +8702,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ LS=$ac_cv_path_LS
+ if test -n "$LS"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
+-$as_echo "$LS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
++printf "%s\n" "$LS" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7801,20 +8727,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xLS" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in ls
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_LS+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $LS in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_LS+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $LS in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_LS="$LS" # Let the user override the test with a path.
+   ;;
+@@ -7823,11 +8750,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_LS="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7835,15 +8766,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ LS=$ac_cv_path_LS
+ if test -n "$LS"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
+-$as_echo "$LS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
++printf "%s\n" "$LS" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7863,16 +8795,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_LS+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $LS in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_LS+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $LS in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_LS="$LS" # Let the user override the test with a path.
+   ;;
+@@ -7881,11 +8814,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_LS="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7893,15 +8830,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ LS=$ac_cv_path_LS
+ if test -n "$LS"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
+-$as_echo "$LS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
++printf "%s\n" "$LS" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7910,17 +8848,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
+-$as_echo_n "checking for LS... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
++printf %s "checking for LS... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -7944,12 +8882,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_MKDIR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $MKDIR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_MKDIR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $MKDIR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
+   ;;
+@@ -7958,11 +8897,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_MKDIR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -7970,15 +8913,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ MKDIR=$ac_cv_path_MKDIR
+ if test -n "$MKDIR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
+-$as_echo "$MKDIR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
++printf "%s\n" "$MKDIR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -7994,20 +8938,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xMKDIR" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in mkdir
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_MKDIR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $MKDIR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_MKDIR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $MKDIR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
+   ;;
+@@ -8016,11 +8961,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_MKDIR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8028,15 +8977,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ MKDIR=$ac_cv_path_MKDIR
+ if test -n "$MKDIR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
+-$as_echo "$MKDIR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
++printf "%s\n" "$MKDIR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8056,16 +9006,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_MKDIR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $MKDIR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_MKDIR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $MKDIR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
+   ;;
+@@ -8074,11 +9025,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_MKDIR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8086,15 +9041,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ MKDIR=$ac_cv_path_MKDIR
+ if test -n "$MKDIR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
+-$as_echo "$MKDIR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
++printf "%s\n" "$MKDIR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8103,17 +9059,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
+-$as_echo_n "checking for MKDIR... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
++printf %s "checking for MKDIR... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -8137,12 +9093,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_MKTEMP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $MKTEMP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_MKTEMP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $MKTEMP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
+   ;;
+@@ -8151,11 +9108,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_MKTEMP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8163,15 +9124,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ MKTEMP=$ac_cv_path_MKTEMP
+ if test -n "$MKTEMP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
+-$as_echo "$MKTEMP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
++printf "%s\n" "$MKTEMP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8187,20 +9149,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xMKTEMP" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in mktemp
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_MKTEMP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $MKTEMP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_MKTEMP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $MKTEMP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
+   ;;
+@@ -8209,11 +9172,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_MKTEMP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8221,15 +9188,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ MKTEMP=$ac_cv_path_MKTEMP
+ if test -n "$MKTEMP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
+-$as_echo "$MKTEMP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
++printf "%s\n" "$MKTEMP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8249,16 +9217,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_MKTEMP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $MKTEMP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_MKTEMP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $MKTEMP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
+   ;;
+@@ -8267,11 +9236,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_MKTEMP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8279,15 +9252,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ MKTEMP=$ac_cv_path_MKTEMP
+ if test -n "$MKTEMP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
+-$as_echo "$MKTEMP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
++printf "%s\n" "$MKTEMP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8296,17 +9270,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
+-$as_echo_n "checking for MKTEMP... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
++printf %s "checking for MKTEMP... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -8330,12 +9304,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_MV+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $MV in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_MV+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $MV in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_MV="$MV" # Let the user override the test with a path.
+   ;;
+@@ -8344,11 +9319,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_MV="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8356,15 +9335,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ MV=$ac_cv_path_MV
+ if test -n "$MV"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
+-$as_echo "$MV" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
++printf "%s\n" "$MV" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8380,20 +9360,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xMV" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in mv
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_MV+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $MV in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_MV+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $MV in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_MV="$MV" # Let the user override the test with a path.
+   ;;
+@@ -8402,11 +9383,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_MV="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8414,15 +9399,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ MV=$ac_cv_path_MV
+ if test -n "$MV"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
+-$as_echo "$MV" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
++printf "%s\n" "$MV" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8442,16 +9428,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_MV+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $MV in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_MV+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $MV in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_MV="$MV" # Let the user override the test with a path.
+   ;;
+@@ -8460,11 +9447,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_MV="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8472,15 +9463,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ MV=$ac_cv_path_MV
+ if test -n "$MV"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
+-$as_echo "$MV" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
++printf "%s\n" "$MV" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8489,17 +9481,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
+-$as_echo_n "checking for MV... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
++printf %s "checking for MV... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -8523,12 +9515,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_NAWK+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $NAWK in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_NAWK+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $NAWK in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
+   ;;
+@@ -8537,11 +9530,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_NAWK="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8549,15 +9546,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ NAWK=$ac_cv_path_NAWK
+ if test -n "$NAWK"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
+-$as_echo "$NAWK" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
++printf "%s\n" "$NAWK" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8573,20 +9571,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xNAWK" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in nawk gawk awk
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_NAWK+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $NAWK in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_NAWK+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $NAWK in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
+   ;;
+@@ -8595,11 +9594,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_NAWK="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8607,15 +9610,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ NAWK=$ac_cv_path_NAWK
+ if test -n "$NAWK"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
+-$as_echo "$NAWK" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
++printf "%s\n" "$NAWK" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8635,16 +9639,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_NAWK+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $NAWK in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_NAWK+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $NAWK in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
+   ;;
+@@ -8653,11 +9658,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_NAWK="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8665,15 +9674,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ NAWK=$ac_cv_path_NAWK
+ if test -n "$NAWK"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
+-$as_echo "$NAWK" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
++printf "%s\n" "$NAWK" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8682,17 +9692,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
+-$as_echo_n "checking for NAWK... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
++printf %s "checking for NAWK... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -8716,12 +9726,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_PRINTF+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $PRINTF in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_PRINTF+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $PRINTF in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
+   ;;
+@@ -8730,11 +9741,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_PRINTF="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8742,15 +9757,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ PRINTF=$ac_cv_path_PRINTF
+ if test -n "$PRINTF"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
+-$as_echo "$PRINTF" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
++printf "%s\n" "$PRINTF" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8766,20 +9782,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xPRINTF" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in printf
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_PRINTF+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $PRINTF in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_PRINTF+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $PRINTF in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
+   ;;
+@@ -8788,11 +9805,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_PRINTF="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8800,15 +9821,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ PRINTF=$ac_cv_path_PRINTF
+ if test -n "$PRINTF"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
+-$as_echo "$PRINTF" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
++printf "%s\n" "$PRINTF" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8828,16 +9850,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_PRINTF+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $PRINTF in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_PRINTF+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $PRINTF in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
+   ;;
+@@ -8846,11 +9869,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_PRINTF="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8858,15 +9885,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ PRINTF=$ac_cv_path_PRINTF
+ if test -n "$PRINTF"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
+-$as_echo "$PRINTF" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
++printf "%s\n" "$PRINTF" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8875,17 +9903,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
+-$as_echo_n "checking for PRINTF... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
++printf %s "checking for PRINTF... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -8909,12 +9937,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_RM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $RM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_RM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $RM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_RM="$RM" # Let the user override the test with a path.
+   ;;
+@@ -8923,11 +9952,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_RM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8935,15 +9968,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ RM=$ac_cv_path_RM
+ if test -n "$RM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
+-$as_echo "$RM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
++printf "%s\n" "$RM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -8959,20 +9993,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xRM" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in rm
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_RM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $RM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_RM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $RM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_RM="$RM" # Let the user override the test with a path.
+   ;;
+@@ -8981,11 +10016,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_RM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -8993,15 +10032,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ RM=$ac_cv_path_RM
+ if test -n "$RM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
+-$as_echo "$RM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
++printf "%s\n" "$RM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9021,16 +10061,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_RM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $RM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_RM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $RM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_RM="$RM" # Let the user override the test with a path.
+   ;;
+@@ -9039,11 +10080,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_RM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9051,15 +10096,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ RM=$ac_cv_path_RM
+ if test -n "$RM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
+-$as_echo "$RM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
++printf "%s\n" "$RM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9068,17 +10114,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
+-$as_echo_n "checking for RM... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
++printf %s "checking for RM... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -9102,12 +10148,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_SH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $SH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_SH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $SH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_SH="$SH" # Let the user override the test with a path.
+   ;;
+@@ -9116,11 +10163,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_SH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9128,15 +10179,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ SH=$ac_cv_path_SH
+ if test -n "$SH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
+-$as_echo "$SH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
++printf "%s\n" "$SH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9152,20 +10204,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xSH" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in sh
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_SH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $SH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_SH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $SH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_SH="$SH" # Let the user override the test with a path.
+   ;;
+@@ -9174,11 +10227,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_SH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9186,15 +10243,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ SH=$ac_cv_path_SH
+ if test -n "$SH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
+-$as_echo "$SH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
++printf "%s\n" "$SH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9214,16 +10272,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_SH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $SH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_SH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $SH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_SH="$SH" # Let the user override the test with a path.
+   ;;
+@@ -9232,11 +10291,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_SH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9244,15 +10307,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ SH=$ac_cv_path_SH
+ if test -n "$SH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
+-$as_echo "$SH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
++printf "%s\n" "$SH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9261,17 +10325,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
+-$as_echo_n "checking for SH... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
++printf %s "checking for SH... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -9295,12 +10359,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_SORT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $SORT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_SORT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $SORT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
+   ;;
+@@ -9309,11 +10374,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_SORT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9321,15 +10390,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ SORT=$ac_cv_path_SORT
+ if test -n "$SORT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
+-$as_echo "$SORT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
++printf "%s\n" "$SORT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9345,20 +10415,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xSORT" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in sort
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_SORT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $SORT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_SORT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $SORT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
+   ;;
+@@ -9367,11 +10438,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_SORT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9379,15 +10454,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ SORT=$ac_cv_path_SORT
+ if test -n "$SORT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
+-$as_echo "$SORT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
++printf "%s\n" "$SORT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9407,16 +10483,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_SORT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $SORT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_SORT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $SORT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
+   ;;
+@@ -9425,11 +10502,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_SORT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9437,15 +10518,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ SORT=$ac_cv_path_SORT
+ if test -n "$SORT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
+-$as_echo "$SORT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
++printf "%s\n" "$SORT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9454,17 +10536,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
+-$as_echo_n "checking for SORT... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
++printf %s "checking for SORT... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -9488,12 +10570,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TAIL+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TAIL in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TAIL+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TAIL in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
+   ;;
+@@ -9502,11 +10585,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TAIL="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9514,15 +10601,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TAIL=$ac_cv_path_TAIL
+ if test -n "$TAIL"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
+-$as_echo "$TAIL" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
++printf "%s\n" "$TAIL" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9538,20 +10626,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xTAIL" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in tail
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TAIL+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TAIL in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TAIL+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TAIL in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
+   ;;
+@@ -9560,11 +10649,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TAIL="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9572,15 +10665,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TAIL=$ac_cv_path_TAIL
+ if test -n "$TAIL"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
+-$as_echo "$TAIL" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
++printf "%s\n" "$TAIL" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9600,16 +10694,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TAIL+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TAIL in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TAIL+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TAIL in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
+   ;;
+@@ -9618,11 +10713,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TAIL="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9630,15 +10729,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TAIL=$ac_cv_path_TAIL
+ if test -n "$TAIL"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
+-$as_echo "$TAIL" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
++printf "%s\n" "$TAIL" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9647,17 +10747,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
+-$as_echo_n "checking for TAIL... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
++printf %s "checking for TAIL... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -9681,12 +10781,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TAR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TAR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TAR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TAR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
+   ;;
+@@ -9695,11 +10796,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TAR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9707,15 +10812,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TAR=$ac_cv_path_TAR
+ if test -n "$TAR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
+-$as_echo "$TAR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
++printf "%s\n" "$TAR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9731,20 +10837,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xTAR" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in tar
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TAR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TAR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TAR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TAR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
+   ;;
+@@ -9753,11 +10860,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TAR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9765,15 +10876,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TAR=$ac_cv_path_TAR
+ if test -n "$TAR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
+-$as_echo "$TAR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
++printf "%s\n" "$TAR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9793,16 +10905,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TAR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TAR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TAR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TAR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
+   ;;
+@@ -9811,11 +10924,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TAR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9823,15 +10940,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TAR=$ac_cv_path_TAR
+ if test -n "$TAR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
+-$as_echo "$TAR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
++printf "%s\n" "$TAR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9840,17 +10958,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
+-$as_echo_n "checking for TAR... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
++printf %s "checking for TAR... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -9874,12 +10992,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TEE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TEE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TEE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TEE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
+   ;;
+@@ -9888,11 +11007,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TEE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9900,15 +11023,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TEE=$ac_cv_path_TEE
+ if test -n "$TEE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
+-$as_echo "$TEE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
++printf "%s\n" "$TEE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9924,20 +11048,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xTEE" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in tee
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TEE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TEE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TEE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TEE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
+   ;;
+@@ -9946,11 +11071,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TEE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -9958,15 +11087,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TEE=$ac_cv_path_TEE
+ if test -n "$TEE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
+-$as_echo "$TEE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
++printf "%s\n" "$TEE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -9986,16 +11116,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TEE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TEE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TEE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TEE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
+   ;;
+@@ -10004,11 +11135,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TEE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10016,15 +11151,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TEE=$ac_cv_path_TEE
+ if test -n "$TEE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
+-$as_echo "$TEE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
++printf "%s\n" "$TEE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10033,17 +11169,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
+-$as_echo_n "checking for TEE... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
++printf %s "checking for TEE... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -10067,12 +11203,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TOUCH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TOUCH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TOUCH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TOUCH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
+   ;;
+@@ -10081,11 +11218,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TOUCH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10093,15 +11234,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TOUCH=$ac_cv_path_TOUCH
+ if test -n "$TOUCH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
+-$as_echo "$TOUCH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
++printf "%s\n" "$TOUCH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10117,20 +11259,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xTOUCH" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in touch
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TOUCH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TOUCH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TOUCH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TOUCH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
+   ;;
+@@ -10139,11 +11282,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TOUCH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10151,15 +11298,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TOUCH=$ac_cv_path_TOUCH
+ if test -n "$TOUCH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
+-$as_echo "$TOUCH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
++printf "%s\n" "$TOUCH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10179,16 +11327,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TOUCH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TOUCH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TOUCH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TOUCH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
+   ;;
+@@ -10197,11 +11346,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TOUCH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10209,15 +11362,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TOUCH=$ac_cv_path_TOUCH
+ if test -n "$TOUCH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
+-$as_echo "$TOUCH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
++printf "%s\n" "$TOUCH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10226,17 +11380,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
+-$as_echo_n "checking for TOUCH... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
++printf %s "checking for TOUCH... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -10260,12 +11414,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TR="$TR" # Let the user override the test with a path.
+   ;;
+@@ -10274,11 +11429,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10286,15 +11445,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TR=$ac_cv_path_TR
+ if test -n "$TR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
+-$as_echo "$TR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
++printf "%s\n" "$TR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10310,20 +11470,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xTR" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in tr
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TR="$TR" # Let the user override the test with a path.
+   ;;
+@@ -10332,11 +11493,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10344,15 +11509,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TR=$ac_cv_path_TR
+ if test -n "$TR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
+-$as_echo "$TR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
++printf "%s\n" "$TR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10372,16 +11538,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TR="$TR" # Let the user override the test with a path.
+   ;;
+@@ -10390,11 +11557,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10402,15 +11573,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TR=$ac_cv_path_TR
+ if test -n "$TR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
+-$as_echo "$TR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
++printf "%s\n" "$TR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10419,17 +11591,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
+-$as_echo_n "checking for TR... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
++printf %s "checking for TR... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -10453,12 +11625,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_UNAME+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $UNAME in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_UNAME+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $UNAME in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
+   ;;
+@@ -10467,11 +11640,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_UNAME="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10479,15 +11656,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ UNAME=$ac_cv_path_UNAME
+ if test -n "$UNAME"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
+-$as_echo "$UNAME" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
++printf "%s\n" "$UNAME" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10503,20 +11681,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xUNAME" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in uname
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_UNAME+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $UNAME in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_UNAME+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $UNAME in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
+   ;;
+@@ -10525,11 +11704,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_UNAME="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10537,15 +11720,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ UNAME=$ac_cv_path_UNAME
+ if test -n "$UNAME"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
+-$as_echo "$UNAME" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
++printf "%s\n" "$UNAME" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10565,16 +11749,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_UNAME+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $UNAME in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_UNAME+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $UNAME in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
+   ;;
+@@ -10583,11 +11768,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_UNAME="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10595,15 +11784,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ UNAME=$ac_cv_path_UNAME
+ if test -n "$UNAME"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
+-$as_echo "$UNAME" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
++printf "%s\n" "$UNAME" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10612,17 +11802,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
+-$as_echo_n "checking for UNAME... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
++printf %s "checking for UNAME... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -10646,12 +11836,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_UNIQ+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $UNIQ in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_UNIQ+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $UNIQ in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
+   ;;
+@@ -10660,11 +11851,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_UNIQ="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10672,15 +11867,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ UNIQ=$ac_cv_path_UNIQ
+ if test -n "$UNIQ"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
+-$as_echo "$UNIQ" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
++printf "%s\n" "$UNIQ" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10696,20 +11892,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xUNIQ" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in uniq
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_UNIQ+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $UNIQ in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_UNIQ+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $UNIQ in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
+   ;;
+@@ -10718,11 +11915,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_UNIQ="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10730,15 +11931,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ UNIQ=$ac_cv_path_UNIQ
+ if test -n "$UNIQ"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
+-$as_echo "$UNIQ" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
++printf "%s\n" "$UNIQ" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10758,16 +11960,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_UNIQ+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $UNIQ in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_UNIQ+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $UNIQ in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
+   ;;
+@@ -10776,11 +11979,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_UNIQ="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10788,15 +11995,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ UNIQ=$ac_cv_path_UNIQ
+ if test -n "$UNIQ"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
+-$as_echo "$UNIQ" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
++printf "%s\n" "$UNIQ" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10805,17 +12013,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
+-$as_echo_n "checking for UNIQ... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
++printf %s "checking for UNIQ... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -10839,12 +12047,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_WC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $WC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_WC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $WC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_WC="$WC" # Let the user override the test with a path.
+   ;;
+@@ -10853,11 +12062,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_WC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10865,15 +12078,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ WC=$ac_cv_path_WC
+ if test -n "$WC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
+-$as_echo "$WC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
++printf "%s\n" "$WC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10889,20 +12103,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xWC" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in wc
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_WC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $WC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_WC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $WC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_WC="$WC" # Let the user override the test with a path.
+   ;;
+@@ -10911,11 +12126,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_WC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10923,15 +12142,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ WC=$ac_cv_path_WC
+ if test -n "$WC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
+-$as_echo "$WC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
++printf "%s\n" "$WC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10951,16 +12171,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_WC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $WC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_WC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $WC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_WC="$WC" # Let the user override the test with a path.
+   ;;
+@@ -10969,11 +12190,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_WC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -10981,15 +12206,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ WC=$ac_cv_path_WC
+ if test -n "$WC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
+-$as_echo "$WC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
++printf "%s\n" "$WC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -10998,17 +12224,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
+-$as_echo_n "checking for WC... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
++printf %s "checking for WC... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -11032,12 +12258,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_WHICH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $WHICH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_WHICH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $WHICH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
+   ;;
+@@ -11046,11 +12273,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_WHICH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -11058,15 +12289,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ WHICH=$ac_cv_path_WHICH
+ if test -n "$WHICH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
+-$as_echo "$WHICH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
++printf "%s\n" "$WHICH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -11082,20 +12314,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xWHICH" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in which
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_WHICH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $WHICH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_WHICH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $WHICH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
+   ;;
+@@ -11104,11 +12337,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_WHICH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -11116,15 +12353,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ WHICH=$ac_cv_path_WHICH
+ if test -n "$WHICH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
+-$as_echo "$WHICH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
++printf "%s\n" "$WHICH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -11144,16 +12382,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_WHICH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $WHICH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_WHICH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $WHICH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
+   ;;
+@@ -11162,11 +12401,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_WHICH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -11174,15 +12417,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ WHICH=$ac_cv_path_WHICH
+ if test -n "$WHICH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
+-$as_echo "$WHICH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
++printf "%s\n" "$WHICH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -11191,17 +12435,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
+-$as_echo_n "checking for WHICH... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
++printf %s "checking for WHICH... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -11225,12 +12469,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_XARGS+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $XARGS in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_XARGS+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $XARGS in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
+   ;;
+@@ -11239,11 +12484,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_XARGS="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -11251,15 +12500,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ XARGS=$ac_cv_path_XARGS
+ if test -n "$XARGS"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
+-$as_echo "$XARGS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
++printf "%s\n" "$XARGS" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -11275,20 +12525,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xXARGS" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in xargs
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_XARGS+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $XARGS in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_XARGS+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $XARGS in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
+   ;;
+@@ -11297,11 +12548,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_XARGS="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -11309,15 +12564,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ XARGS=$ac_cv_path_XARGS
+ if test -n "$XARGS"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
+-$as_echo "$XARGS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
++printf "%s\n" "$XARGS" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -11337,16 +12593,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_XARGS+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $XARGS in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_XARGS+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $XARGS in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
+   ;;
+@@ -11355,11 +12612,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_XARGS="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -11367,15 +12628,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ XARGS=$ac_cv_path_XARGS
+ if test -n "$XARGS"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
+-$as_echo "$XARGS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
++printf "%s\n" "$XARGS" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -11384,17 +12646,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
+-$as_echo_n "checking for XARGS... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
++printf %s "checking for XARGS... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -11419,38 +12681,44 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_AWK+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$AWK"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_AWK+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$AWK"; then
+   ac_cv_prog_AWK="$AWK" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_AWK="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ AWK=$ac_cv_prog_AWK
+ if test -n "$AWK"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+-$as_echo "$AWK" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
++printf "%s\n" "$AWK" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -11466,46 +12734,52 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xAWK" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in gawk mawk nawk awk
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_AWK+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$AWK"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_AWK+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$AWK"; then
+   ac_cv_prog_AWK="$AWK" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_AWK="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ AWK=$ac_cv_prog_AWK
+ if test -n "$AWK"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+-$as_echo "$AWK" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
++printf "%s\n" "$AWK" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -11525,16 +12799,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_AWK+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $AWK in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_AWK+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $AWK in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
+   ;;
+@@ -11543,11 +12818,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_AWK="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -11555,15 +12834,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ AWK=$ac_cv_path_AWK
+ if test -n "$AWK"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+-$as_echo "$AWK" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
++printf "%s\n" "$AWK" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -11572,17 +12852,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
+-$as_echo_n "checking for AWK... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
++printf %s "checking for AWK... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -11600,37 +12880,44 @@ $as_echo "$tool_specified" >&6; }
+ 
+   if test "x$GREP" = x; then
+     # The variable is not set by user, try to locate tool using the code snippet
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+-$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+-if ${ac_cv_path_GREP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -z "$GREP"; then
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
++printf %s "checking for grep that handles long lines and -e... " >&6; }
++if test ${ac_cv_path_GREP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -z "$GREP"; then
+   ac_path_GREP_found=false
+   # Loop through the user's path and test for each of PROGNAME-LIST
+   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-    for ac_prog in grep ggrep; do
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
++    for ac_prog in grep ggrep
++   do
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
++      ac_path_GREP="$as_dir$ac_prog$ac_exec_ext"
+       as_fn_executable_p "$ac_path_GREP" || continue
+ # Check for GNU ac_path_GREP and select it if it is found.
+   # Check for GNU $ac_path_GREP
+-case `"$ac_path_GREP" --version 2>&1` in
++case `"$ac_path_GREP" --version 2>&1` in #(
+ *GNU*)
+   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
++#(
+ *)
+   ac_count=0
+-  $as_echo_n 0123456789 >"conftest.in"
++  printf %s 0123456789 >"conftest.in"
+   while :
+   do
+     cat "conftest.in" "conftest.in" >"conftest.tmp"
+     mv "conftest.tmp" "conftest.in"
+     cp "conftest.in" "conftest.nl"
+-    $as_echo 'GREP' >> "conftest.nl"
++    printf "%s\n" 'GREP' >> "conftest.nl"
+     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+     as_fn_arith $ac_count + 1 && ac_count=$as_val
+@@ -11656,10 +12943,11 @@ IFS=$as_save_IFS
+ else
+   ac_cv_path_GREP=$GREP
+ fi
+-
++ ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+-$as_echo "$ac_cv_path_GREP" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
++printf "%s\n" "$ac_cv_path_GREP" >&6; }
+  GREP="$ac_cv_path_GREP"
+ 
+ 
+@@ -11672,41 +12960,48 @@ $as_echo "$ac_cv_path_GREP" >&6; }
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xGREP" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+-$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+-if ${ac_cv_path_GREP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -z "$GREP"; then
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
++printf %s "checking for grep that handles long lines and -e... " >&6; }
++if test ${ac_cv_path_GREP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -z "$GREP"; then
+   ac_path_GREP_found=false
+   # Loop through the user's path and test for each of PROGNAME-LIST
+   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-    for ac_prog in grep ggrep; do
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
++    for ac_prog in grep ggrep
++   do
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
++      ac_path_GREP="$as_dir$ac_prog$ac_exec_ext"
+       as_fn_executable_p "$ac_path_GREP" || continue
+ # Check for GNU ac_path_GREP and select it if it is found.
+   # Check for GNU $ac_path_GREP
+-case `"$ac_path_GREP" --version 2>&1` in
++case `"$ac_path_GREP" --version 2>&1` in #(
+ *GNU*)
+   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
++#(
+ *)
+   ac_count=0
+-  $as_echo_n 0123456789 >"conftest.in"
++  printf %s 0123456789 >"conftest.in"
+   while :
+   do
+     cat "conftest.in" "conftest.in" >"conftest.tmp"
+     mv "conftest.tmp" "conftest.in"
+     cp "conftest.in" "conftest.nl"
+-    $as_echo 'GREP' >> "conftest.nl"
++    printf "%s\n" 'GREP' >> "conftest.nl"
+     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+     as_fn_arith $ac_count + 1 && ac_count=$as_val
+@@ -11732,10 +13027,11 @@ IFS=$as_save_IFS
+ else
+   ac_cv_path_GREP=$GREP
+ fi
+-
++ ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+-$as_echo "$ac_cv_path_GREP" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
++printf "%s\n" "$ac_cv_path_GREP" >&6; }
+  GREP="$ac_cv_path_GREP"
+ 
+ 
+@@ -11752,16 +13048,17 @@ $as_echo "$ac_cv_path_GREP" >&6; }
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_GREP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $GREP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_GREP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $GREP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
+   ;;
+@@ -11770,11 +13067,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_GREP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -11782,15 +13083,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ GREP=$ac_cv_path_GREP
+ if test -n "$GREP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
+-$as_echo "$GREP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
++printf "%s\n" "$GREP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -11799,17 +13101,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
+-$as_echo_n "checking for GREP... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
++printf %s "checking for GREP... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -11827,12 +13129,13 @@ $as_echo "$tool_specified" >&6; }
+ 
+   if test "x$EGREP" = x; then
+     # The variable is not set by user, try to locate tool using the code snippet
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+-$as_echo_n "checking for egrep... " >&6; }
+-if ${ac_cv_path_EGREP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
++printf %s "checking for egrep... " >&6; }
++if test ${ac_cv_path_EGREP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+    then ac_cv_path_EGREP="$GREP -E"
+    else
+      if test -z "$EGREP"; then
+@@ -11842,25 +13145,31 @@ else
+ for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-    for ac_prog in egrep; do
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
++    for ac_prog in egrep
++   do
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
++      ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext"
+       as_fn_executable_p "$ac_path_EGREP" || continue
+ # Check for GNU ac_path_EGREP and select it if it is found.
+   # Check for GNU $ac_path_EGREP
+-case `"$ac_path_EGREP" --version 2>&1` in
++case `"$ac_path_EGREP" --version 2>&1` in #(
+ *GNU*)
+   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
++#(
+ *)
+   ac_count=0
+-  $as_echo_n 0123456789 >"conftest.in"
++  printf %s 0123456789 >"conftest.in"
+   while :
+   do
+     cat "conftest.in" "conftest.in" >"conftest.tmp"
+     mv "conftest.tmp" "conftest.in"
+     cp "conftest.in" "conftest.nl"
+-    $as_echo 'EGREP' >> "conftest.nl"
++    printf "%s\n" 'EGREP' >> "conftest.nl"
+     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+     as_fn_arith $ac_count + 1 && ac_count=$as_val
+@@ -11887,12 +13196,15 @@ else
+   ac_cv_path_EGREP=$EGREP
+ fi
+ 
+-   fi
++   fi ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+-$as_echo "$ac_cv_path_EGREP" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
++printf "%s\n" "$ac_cv_path_EGREP" >&6; }
+  EGREP="$ac_cv_path_EGREP"
+ 
++         EGREP_TRADITIONAL=$EGREP
++ ac_cv_path_EGREP_TRADITIONAL=$EGREP
+ 
+   else
+     # The variable is set, but is it from the command line or the environment?
+@@ -11903,16 +13215,17 @@ $as_echo "$ac_cv_path_EGREP" >&6; }
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xEGREP" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+-$as_echo_n "checking for egrep... " >&6; }
+-if ${ac_cv_path_EGREP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
++printf %s "checking for egrep... " >&6; }
++if test ${ac_cv_path_EGREP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+    then ac_cv_path_EGREP="$GREP -E"
+    else
+      if test -z "$EGREP"; then
+@@ -11922,25 +13235,31 @@ else
+ for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-    for ac_prog in egrep; do
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
++    for ac_prog in egrep
++   do
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
++      ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext"
+       as_fn_executable_p "$ac_path_EGREP" || continue
+ # Check for GNU ac_path_EGREP and select it if it is found.
+   # Check for GNU $ac_path_EGREP
+-case `"$ac_path_EGREP" --version 2>&1` in
++case `"$ac_path_EGREP" --version 2>&1` in #(
+ *GNU*)
+   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
++#(
+ *)
+   ac_count=0
+-  $as_echo_n 0123456789 >"conftest.in"
++  printf %s 0123456789 >"conftest.in"
+   while :
+   do
+     cat "conftest.in" "conftest.in" >"conftest.tmp"
+     mv "conftest.tmp" "conftest.in"
+     cp "conftest.in" "conftest.nl"
+-    $as_echo 'EGREP' >> "conftest.nl"
++    printf "%s\n" 'EGREP' >> "conftest.nl"
+     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+     as_fn_arith $ac_count + 1 && ac_count=$as_val
+@@ -11967,12 +13286,15 @@ else
+   ac_cv_path_EGREP=$EGREP
+ fi
+ 
+-   fi
++   fi ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+-$as_echo "$ac_cv_path_EGREP" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
++printf "%s\n" "$ac_cv_path_EGREP" >&6; }
+  EGREP="$ac_cv_path_EGREP"
+ 
++         EGREP_TRADITIONAL=$EGREP
++ ac_cv_path_EGREP_TRADITIONAL=$EGREP
+ 
+     else
+       # If it succeeded, then it was overridden by the user. We will use it
+@@ -11987,16 +13309,17 @@ $as_echo "$ac_cv_path_EGREP" >&6; }
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_EGREP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $EGREP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_EGREP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $EGREP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
+   ;;
+@@ -12005,11 +13328,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_EGREP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -12017,15 +13344,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ EGREP=$ac_cv_path_EGREP
+ if test -n "$EGREP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
+-$as_echo "$EGREP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
++printf "%s\n" "$EGREP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -12034,17 +13362,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
+-$as_echo_n "checking for EGREP... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
++printf %s "checking for EGREP... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -12062,12 +13390,13 @@ $as_echo "$tool_specified" >&6; }
+ 
+   if test "x$FGREP" = x; then
+     # The variable is not set by user, try to locate tool using the code snippet
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
+-$as_echo_n "checking for fgrep... " >&6; }
+-if ${ac_cv_path_FGREP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
++printf %s "checking for fgrep... " >&6; }
++if test ${ac_cv_path_FGREP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
+    then ac_cv_path_FGREP="$GREP -F"
+    else
+      if test -z "$FGREP"; then
+@@ -12077,25 +13406,31 @@ else
+ for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-    for ac_prog in fgrep; do
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
++    for ac_prog in fgrep
++   do
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-      ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
++      ac_path_FGREP="$as_dir$ac_prog$ac_exec_ext"
+       as_fn_executable_p "$ac_path_FGREP" || continue
+ # Check for GNU ac_path_FGREP and select it if it is found.
+   # Check for GNU $ac_path_FGREP
+-case `"$ac_path_FGREP" --version 2>&1` in
++case `"$ac_path_FGREP" --version 2>&1` in #(
+ *GNU*)
+   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
++#(
+ *)
+   ac_count=0
+-  $as_echo_n 0123456789 >"conftest.in"
++  printf %s 0123456789 >"conftest.in"
+   while :
+   do
+     cat "conftest.in" "conftest.in" >"conftest.tmp"
+     mv "conftest.tmp" "conftest.in"
+     cp "conftest.in" "conftest.nl"
+-    $as_echo 'FGREP' >> "conftest.nl"
++    printf "%s\n" 'FGREP' >> "conftest.nl"
+     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
+     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+     as_fn_arith $ac_count + 1 && ac_count=$as_val
+@@ -12122,10 +13457,11 @@ else
+   ac_cv_path_FGREP=$FGREP
+ fi
+ 
+-   fi
++   fi ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
+-$as_echo "$ac_cv_path_FGREP" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
++printf "%s\n" "$ac_cv_path_FGREP" >&6; }
+  FGREP="$ac_cv_path_FGREP"
+ 
+ 
+@@ -12138,16 +13474,17 @@ $as_echo "$ac_cv_path_FGREP" >&6; }
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xFGREP" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
+-$as_echo_n "checking for fgrep... " >&6; }
+-if ${ac_cv_path_FGREP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
++printf %s "checking for fgrep... " >&6; }
++if test ${ac_cv_path_FGREP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
+    then ac_cv_path_FGREP="$GREP -F"
+    else
+      if test -z "$FGREP"; then
+@@ -12157,25 +13494,31 @@ else
+ for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-    for ac_prog in fgrep; do
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
++    for ac_prog in fgrep
++   do
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-      ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
++      ac_path_FGREP="$as_dir$ac_prog$ac_exec_ext"
+       as_fn_executable_p "$ac_path_FGREP" || continue
+ # Check for GNU ac_path_FGREP and select it if it is found.
+   # Check for GNU $ac_path_FGREP
+-case `"$ac_path_FGREP" --version 2>&1` in
++case `"$ac_path_FGREP" --version 2>&1` in #(
+ *GNU*)
+   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
++#(
+ *)
+   ac_count=0
+-  $as_echo_n 0123456789 >"conftest.in"
++  printf %s 0123456789 >"conftest.in"
+   while :
+   do
+     cat "conftest.in" "conftest.in" >"conftest.tmp"
+     mv "conftest.tmp" "conftest.in"
+     cp "conftest.in" "conftest.nl"
+-    $as_echo 'FGREP' >> "conftest.nl"
++    printf "%s\n" 'FGREP' >> "conftest.nl"
+     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
+     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+     as_fn_arith $ac_count + 1 && ac_count=$as_val
+@@ -12202,10 +13545,11 @@ else
+   ac_cv_path_FGREP=$FGREP
+ fi
+ 
+-   fi
++   fi ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
+-$as_echo "$ac_cv_path_FGREP" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
++printf "%s\n" "$ac_cv_path_FGREP" >&6; }
+  FGREP="$ac_cv_path_FGREP"
+ 
+ 
+@@ -12222,16 +13566,17 @@ $as_echo "$ac_cv_path_FGREP" >&6; }
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_FGREP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $FGREP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_FGREP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $FGREP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
+   ;;
+@@ -12240,11 +13585,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_FGREP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -12252,15 +13601,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ FGREP=$ac_cv_path_FGREP
+ if test -n "$FGREP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
+-$as_echo "$FGREP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
++printf "%s\n" "$FGREP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -12269,17 +13619,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
+-$as_echo_n "checking for FGREP... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
++printf %s "checking for FGREP... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -12297,12 +13647,13 @@ $as_echo "$tool_specified" >&6; }
+ 
+   if test "x$SED" = x; then
+     # The variable is not set by user, try to locate tool using the code snippet
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+-$as_echo_n "checking for a sed that does not truncate output... " >&6; }
+-if ${ac_cv_path_SED+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
++printf %s "checking for a sed that does not truncate output... " >&6; }
++if test ${ac_cv_path_SED+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e)           ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+      for ac_i in 1 2 3 4 5 6 7; do
+        ac_script="$ac_script$as_nl$ac_script"
+      done
+@@ -12315,25 +13666,31 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-    for ac_prog in sed gsed; do
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
++    for ac_prog in sed gsed
++   do
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
++      ac_path_SED="$as_dir$ac_prog$ac_exec_ext"
+       as_fn_executable_p "$ac_path_SED" || continue
+ # Check for GNU ac_path_SED and select it if it is found.
+   # Check for GNU $ac_path_SED
+-case `"$ac_path_SED" --version 2>&1` in
++case `"$ac_path_SED" --version 2>&1` in #(
+ *GNU*)
+   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
++#(
+ *)
+   ac_count=0
+-  $as_echo_n 0123456789 >"conftest.in"
++  printf %s 0123456789 >"conftest.in"
+   while :
+   do
+     cat "conftest.in" "conftest.in" >"conftest.tmp"
+     mv "conftest.tmp" "conftest.in"
+     cp "conftest.in" "conftest.nl"
+-    $as_echo '' >> "conftest.nl"
++    printf "%s\n" '' >> "conftest.nl"
+     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
+     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+     as_fn_arith $ac_count + 1 && ac_count=$as_val
+@@ -12359,10 +13716,11 @@ IFS=$as_save_IFS
+ else
+   ac_cv_path_SED=$SED
+ fi
+-
++ ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+-$as_echo "$ac_cv_path_SED" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
++printf "%s\n" "$ac_cv_path_SED" >&6; }
+  SED="$ac_cv_path_SED"
+   rm -f conftest.sed
+ 
+@@ -12375,16 +13733,17 @@ $as_echo "$ac_cv_path_SED" >&6; }
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xSED" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+-$as_echo_n "checking for a sed that does not truncate output... " >&6; }
+-if ${ac_cv_path_SED+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
++printf %s "checking for a sed that does not truncate output... " >&6; }
++if test ${ac_cv_path_SED+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e)           ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+      for ac_i in 1 2 3 4 5 6 7; do
+        ac_script="$ac_script$as_nl$ac_script"
+      done
+@@ -12397,25 +13756,31 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-    for ac_prog in sed gsed; do
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
++    for ac_prog in sed gsed
++   do
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
++      ac_path_SED="$as_dir$ac_prog$ac_exec_ext"
+       as_fn_executable_p "$ac_path_SED" || continue
+ # Check for GNU ac_path_SED and select it if it is found.
+   # Check for GNU $ac_path_SED
+-case `"$ac_path_SED" --version 2>&1` in
++case `"$ac_path_SED" --version 2>&1` in #(
+ *GNU*)
+   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
++#(
+ *)
+   ac_count=0
+-  $as_echo_n 0123456789 >"conftest.in"
++  printf %s 0123456789 >"conftest.in"
+   while :
+   do
+     cat "conftest.in" "conftest.in" >"conftest.tmp"
+     mv "conftest.tmp" "conftest.in"
+     cp "conftest.in" "conftest.nl"
+-    $as_echo '' >> "conftest.nl"
++    printf "%s\n" '' >> "conftest.nl"
+     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
+     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+     as_fn_arith $ac_count + 1 && ac_count=$as_val
+@@ -12441,10 +13806,11 @@ IFS=$as_save_IFS
+ else
+   ac_cv_path_SED=$SED
+ fi
+-
++ ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+-$as_echo "$ac_cv_path_SED" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
++printf "%s\n" "$ac_cv_path_SED" >&6; }
+  SED="$ac_cv_path_SED"
+   rm -f conftest.sed
+ 
+@@ -12461,16 +13827,17 @@ $as_echo "$ac_cv_path_SED" >&6; }
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_SED+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $SED in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_SED+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $SED in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_SED="$SED" # Let the user override the test with a path.
+   ;;
+@@ -12479,11 +13846,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_SED="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -12491,15 +13862,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ SED=$ac_cv_path_SED
+ if test -n "$SED"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
+-$as_echo "$SED" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
++printf "%s\n" "$SED" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -12508,17 +13880,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
+-$as_echo_n "checking for SED... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
++printf %s "checking for SED... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -12549,12 +13921,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CYGPATH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CYGPATH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CYGPATH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CYGPATH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
+   ;;
+@@ -12563,11 +13936,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CYGPATH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -12575,15 +13952,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CYGPATH=$ac_cv_path_CYGPATH
+ if test -n "$CYGPATH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
+-$as_echo "$CYGPATH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
++printf "%s\n" "$CYGPATH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -12599,20 +13977,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xCYGPATH" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in cygpath
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CYGPATH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CYGPATH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CYGPATH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CYGPATH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
+   ;;
+@@ -12621,11 +14000,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CYGPATH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -12633,15 +14016,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CYGPATH=$ac_cv_path_CYGPATH
+ if test -n "$CYGPATH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
+-$as_echo "$CYGPATH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
++printf "%s\n" "$CYGPATH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -12661,16 +14045,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CYGPATH+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CYGPATH in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CYGPATH+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CYGPATH in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
+   ;;
+@@ -12679,11 +14064,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CYGPATH="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -12691,15 +14080,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CYGPATH=$ac_cv_path_CYGPATH
+ if test -n "$CYGPATH"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
+-$as_echo "$CYGPATH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
++printf "%s\n" "$CYGPATH" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -12708,17 +14098,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
+-$as_echo_n "checking for CYGPATH... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
++printf %s "checking for CYGPATH... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -12735,12 +14125,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_READLINK+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $READLINK in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_READLINK+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $READLINK in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
+   ;;
+@@ -12749,11 +14140,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_READLINK="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -12761,15 +14156,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ READLINK=$ac_cv_path_READLINK
+ if test -n "$READLINK"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
+-$as_echo "$READLINK" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
++printf "%s\n" "$READLINK" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -12785,20 +14181,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xREADLINK" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in greadlink readlink
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_READLINK+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $READLINK in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_READLINK+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $READLINK in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
+   ;;
+@@ -12807,11 +14204,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_READLINK="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -12819,15 +14220,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ READLINK=$ac_cv_path_READLINK
+ if test -n "$READLINK"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
+-$as_echo "$READLINK" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
++printf "%s\n" "$READLINK" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -12847,16 +14249,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_READLINK+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $READLINK in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_READLINK+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $READLINK in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
+   ;;
+@@ -12865,11 +14268,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_READLINK="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -12877,15 +14284,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ READLINK=$ac_cv_path_READLINK
+ if test -n "$READLINK"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
+-$as_echo "$READLINK" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
++printf "%s\n" "$READLINK" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -12894,17 +14302,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
+-$as_echo_n "checking for READLINK... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
++printf %s "checking for READLINK... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -12921,12 +14329,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DF+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DF in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DF+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DF in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DF="$DF" # Let the user override the test with a path.
+   ;;
+@@ -12935,11 +14344,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DF="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -12947,15 +14360,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DF=$ac_cv_path_DF
+ if test -n "$DF"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
+-$as_echo "$DF" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
++printf "%s\n" "$DF" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -12971,20 +14385,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xDF" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in df
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DF+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DF in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DF+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DF in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DF="$DF" # Let the user override the test with a path.
+   ;;
+@@ -12993,11 +14408,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DF="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -13005,15 +14424,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DF=$ac_cv_path_DF
+ if test -n "$DF"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
+-$as_echo "$DF" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
++printf "%s\n" "$DF" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -13033,16 +14453,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DF+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DF in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DF+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DF in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DF="$DF" # Let the user override the test with a path.
+   ;;
+@@ -13051,11 +14472,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DF="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -13063,15 +14488,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DF=$ac_cv_path_DF
+ if test -n "$DF"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
+-$as_echo "$DF" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
++printf "%s\n" "$DF" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -13080,17 +14506,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
+-$as_echo_n "checking for DF... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
++printf %s "checking for DF... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -13107,12 +14533,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_SETFILE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $SETFILE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_SETFILE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $SETFILE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
+   ;;
+@@ -13121,11 +14548,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_SETFILE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -13133,15 +14564,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ SETFILE=$ac_cv_path_SETFILE
+ if test -n "$SETFILE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
+-$as_echo "$SETFILE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
++printf "%s\n" "$SETFILE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -13157,20 +14589,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xSETFILE" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in SetFile
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_SETFILE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $SETFILE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_SETFILE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $SETFILE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
+   ;;
+@@ -13179,11 +14612,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_SETFILE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -13191,15 +14628,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ SETFILE=$ac_cv_path_SETFILE
+ if test -n "$SETFILE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
+-$as_echo "$SETFILE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
++printf "%s\n" "$SETFILE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -13219,16 +14657,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_SETFILE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $SETFILE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_SETFILE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $SETFILE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
+   ;;
+@@ -13237,11 +14676,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_SETFILE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -13249,15 +14692,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ SETFILE=$ac_cv_path_SETFILE
+ if test -n "$SETFILE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
+-$as_echo "$SETFILE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
++printf "%s\n" "$SETFILE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -13266,17 +14710,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
+-$as_echo_n "checking for SETFILE... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
++printf %s "checking for SETFILE... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -13293,12 +14737,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CPIO+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CPIO in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CPIO+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CPIO in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
+   ;;
+@@ -13307,11 +14752,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CPIO="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -13319,15 +14768,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CPIO=$ac_cv_path_CPIO
+ if test -n "$CPIO"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
+-$as_echo "$CPIO" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
++printf "%s\n" "$CPIO" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -13343,20 +14793,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xCPIO" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in cpio bsdcpio
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CPIO+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CPIO in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CPIO+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CPIO in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
+   ;;
+@@ -13365,11 +14816,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CPIO="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -13377,15 +14832,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CPIO=$ac_cv_path_CPIO
+ if test -n "$CPIO"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
+-$as_echo "$CPIO" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
++printf "%s\n" "$CPIO" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -13405,16 +14861,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CPIO+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CPIO in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CPIO+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CPIO in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
+   ;;
+@@ -13423,11 +14880,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CPIO="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -13435,15 +14896,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CPIO=$ac_cv_path_CPIO
+ if test -n "$CPIO"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
+-$as_echo "$CPIO" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
++printf "%s\n" "$CPIO" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -13452,17 +14914,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
+-$as_echo_n "checking for CPIO... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
++printf %s "checking for CPIO... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -13479,12 +14941,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_PANDOC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $PANDOC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_PANDOC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $PANDOC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_PANDOC="$PANDOC" # Let the user override the test with a path.
+   ;;
+@@ -13493,11 +14956,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_PANDOC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_PANDOC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -13505,15 +14972,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ PANDOC=$ac_cv_path_PANDOC
+ if test -n "$PANDOC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
+-$as_echo "$PANDOC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
++printf "%s\n" "$PANDOC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -13529,20 +14997,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xPANDOC" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PANDOC from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of PANDOC from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PANDOC from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of PANDOC from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in pandoc
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_PANDOC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $PANDOC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_PANDOC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $PANDOC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_PANDOC="$PANDOC" # Let the user override the test with a path.
+   ;;
+@@ -13551,11 +15020,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_PANDOC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_PANDOC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -13563,15 +15036,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ PANDOC=$ac_cv_path_PANDOC
+ if test -n "$PANDOC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
+-$as_echo "$PANDOC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
++printf "%s\n" "$PANDOC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -13591,16 +15065,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PANDOC=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool PANDOC=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PANDOC=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool PANDOC=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_PANDOC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $PANDOC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_PANDOC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $PANDOC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_PANDOC="$PANDOC" # Let the user override the test with a path.
+   ;;
+@@ -13609,11 +15084,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_PANDOC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_PANDOC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -13621,15 +15100,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ PANDOC=$ac_cv_path_PANDOC
+ if test -n "$PANDOC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
+-$as_echo "$PANDOC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
++printf "%s\n" "$PANDOC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -13638,17 +15118,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PANDOC=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool PANDOC=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PANDOC" >&5
+-$as_echo_n "checking for PANDOC... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PANDOC=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool PANDOC=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for PANDOC" >&5
++printf %s "checking for PANDOC... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool PANDOC=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -13658,26 +15138,31 @@ $as_echo "$tool_specified" >&6; }
+ 
+ # Now we can determine OpenJDK build and target platforms. This is required to
+ # have early on.
+-# Make sure we can run config.sub.
+-$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
+-  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
+ 
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
+-$as_echo_n "checking build system type... " >&6; }
+-if ${ac_cv_build+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_build_alias=$build_alias
++
++
++  # Make sure we can run config.sub.
++$SHELL "${ac_aux_dir}config.sub" sun4 >/dev/null 2>&1 ||
++  as_fn_error $? "cannot run $SHELL ${ac_aux_dir}config.sub" "$LINENO" 5
++
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
++printf %s "checking build system type... " >&6; }
++if test ${ac_cv_build+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_build_alias=$build_alias
+ test "x$ac_build_alias" = x &&
+-  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
++  ac_build_alias=`$SHELL "${ac_aux_dir}config.guess"`
+ test "x$ac_build_alias" = x &&
+   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
+-ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
+-  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
+-
++ac_cv_build=`$SHELL "${ac_aux_dir}config.sub" $ac_build_alias` ||
++  as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $ac_build_alias failed" "$LINENO" 5
++ ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
+-$as_echo "$ac_cv_build" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
++printf "%s\n" "$ac_cv_build" >&6; }
+ case $ac_cv_build in
+ *-*-*) ;;
+ *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
+@@ -13696,21 +15181,23 @@ IFS=$ac_save_IFS
+ case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+ 
+ 
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
+-$as_echo_n "checking host system type... " >&6; }
+-if ${ac_cv_host+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test "x$host_alias" = x; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
++printf %s "checking host system type... " >&6; }
++if test ${ac_cv_host+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test "x$host_alias" = x; then
+   ac_cv_host=$ac_cv_build
+ else
+-  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
+-    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
++  ac_cv_host=`$SHELL "${ac_aux_dir}config.sub" $host_alias` ||
++    as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $host_alias failed" "$LINENO" 5
+ fi
+-
++ ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
+-$as_echo "$ac_cv_host" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
++printf "%s\n" "$ac_cv_host" >&6; }
+ case $ac_cv_host in
+ *-*-*) ;;
+ *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
+@@ -13729,21 +15216,23 @@ IFS=$ac_save_IFS
+ case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+ 
+ 
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
+-$as_echo_n "checking target system type... " >&6; }
+-if ${ac_cv_target+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test "x$target_alias" = x; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
++printf %s "checking target system type... " >&6; }
++if test ${ac_cv_target+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test "x$target_alias" = x; then
+   ac_cv_target=$ac_cv_host
+ else
+-  ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
+-    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
++  ac_cv_target=`$SHELL "${ac_aux_dir}config.sub" $target_alias` ||
++    as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $target_alias failed" "$LINENO" 5
+ fi
+-
++ ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
+-$as_echo "$ac_cv_target" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
++printf "%s\n" "$ac_cv_target" >&6; }
+ case $ac_cv_target in
+ *-*-*) ;;
+ *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
+@@ -13788,7 +15277,7 @@ test -n "$target_alias" &&
+ 
+ 
+ 
+-  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
++  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
+ 
+   case "$build_os" in
+     *linux*)
+@@ -13917,6 +15406,19 @@ test -n "$target_alias" &&
+       ;;
+   esac
+ 
++
++  case "$build_os" in
++    *linux*-musl)
++      VAR_LIBC=musl
++      ;;
++    *linux*-gnu)
++      VAR_LIBC=gnu
++      ;;
++    *)
++      VAR_LIBC=default
++      ;;
++  esac
++
+   # ..and setup our own variables. (Do this explicitely to facilitate searching)
+   OPENJDK_BUILD_OS="$VAR_OS"
+   OPENJDK_BUILD_OS_API="$VAR_OS_API"
+@@ -13925,6 +15427,9 @@ test -n "$target_alias" &&
+   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
+   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
+   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
++  OPENJDK_BUILD_LIBC="$VAR_LIBC"
++
++
+ 
+ 
+ 
+@@ -13932,13 +15437,19 @@ test -n "$target_alias" &&
+ 
+ 
+ 
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
++printf %s "checking openjdk-build os-cpu... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
++printf "%s\n" "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
+-$as_echo_n "checking openjdk-build os-cpu... " >&6; }
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
+-$as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
++  if test "x$OPENJDK_BUILD_OS" = "xlinux"; then
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking openjdk-build C library" >&5
++printf %s "checking openjdk-build C library... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_LIBC" >&5
++printf "%s\n" "$OPENJDK_BUILD_LIBC" >&6; }
++  fi
+ 
+-  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
++  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
+ 
+   case "$host_os" in
+     *linux*)
+@@ -14067,6 +15578,19 @@ $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
+       ;;
+   esac
+ 
++
++  case "$host_os" in
++    *linux*-musl)
++      VAR_LIBC=musl
++      ;;
++    *linux*-gnu)
++      VAR_LIBC=gnu
++      ;;
++    *)
++      VAR_LIBC=default
++      ;;
++  esac
++
+   # ... and setup our own variables. (Do this explicitely to facilitate searching)
+   OPENJDK_TARGET_OS="$VAR_OS"
+   OPENJDK_TARGET_OS_API="$VAR_OS_API"
+@@ -14075,6 +15599,8 @@ $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
+   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
+   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
+   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
++  OPENJDK_TARGET_LIBC="$VAR_LIBC"
++
+ 
+ 
+ 
+@@ -14083,15 +15609,23 @@ $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
+ 
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
+-$as_echo_n "checking openjdk-target os-cpu... " >&6; }
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
+-$as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
++printf %s "checking openjdk-target os-cpu... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
++printf "%s\n" "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
++
++  if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking openjdk-target C library" >&5
++printf %s "checking openjdk-target C library... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_LIBC" >&5
++printf "%s\n" "$OPENJDK_TARGET_LIBC" >&6; }
++  fi
+ 
+ 
+ 
+ # Check whether --with-target-bits was given.
+-if test "${with_target_bits+set}" = set; then :
++if test ${with_target_bits+y}
++then :
+   withval=$with_target_bits;
+ fi
+ 
+@@ -14127,18 +15661,18 @@ fi
+     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+       as_fn_error $? "It is not possible to use --with-target-bits=64 on a 32 bit system. Use proper cross-compilation instead." "$LINENO" 5
+     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
+-$as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
++printf "%s\n" "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
+     else
+       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
+     fi
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
+-$as_echo_n "checking compilation type... " >&6; }
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
+-$as_echo "$COMPILE_TYPE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
++printf %s "checking compilation type... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
++printf "%s\n" "$COMPILE_TYPE" >&6; }
+ 
+ 
+   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
+@@ -14303,48 +15837,48 @@ $as_echo "$COMPILE_TYPE" >&6; }
+   fi
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
+-$as_echo_n "checking cygwin release... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
++printf %s "checking cygwin release... " >&6; }
+     CYGWIN_VERSION=`$UNAME -r`
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
+-$as_echo "$CYGWIN_VERSION" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
++printf "%s\n" "$CYGWIN_VERSION" >&6; }
+     WINDOWS_ENV_VENDOR='cygwin'
+     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
+ 
+     CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
+     if test "x$CYGWIN_VERSION_OLD" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&5
+-$as_echo "$as_me: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&5
++printf "%s\n" "$as_me: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&6;}
+       as_fn_error $? "Cannot continue" "$LINENO" 5
+     fi
+     if test "x$CYGPATH" = x; then
+       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
+     fi
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
+-$as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
++printf %s "checking cygwin root directory as unix-style path... " >&6; }
+     # The cmd output ends with Windows line endings (CR/LF)
+     cygwin_winpath_root=`cd / ; cmd /c cd | $TR -d '\r\n'`
+     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
+     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
+-$as_echo "$CYGWIN_ROOT_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
++printf "%s\n" "$CYGWIN_ROOT_PATH" >&6; }
+     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
+     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
+     if test "x$test_cygdrive_prefix" = x; then
+       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
+     fi
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
+-$as_echo_n "checking msys release... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
++printf %s "checking msys release... " >&6; }
+     MSYS_VERSION=`$UNAME -r`
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
+-$as_echo "$MSYS_VERSION" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
++printf "%s\n" "$MSYS_VERSION" >&6; }
+ 
+     WINDOWS_ENV_VENDOR='msys'
+     WINDOWS_ENV_VERSION="$MSYS_VERSION"
+ 
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
+-$as_echo_n "checking msys root directory as unix-style path... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
++printf %s "checking msys root directory as unix-style path... " >&6; }
+     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
+     MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
+ 
+@@ -14357,33 +15891,33 @@ $as_echo_n "checking msys root directory as unix-style path... " >&6; }
+     MSYS_ROOT_PATH="$unix_path"
+   fi
+ 
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
+-$as_echo "$MSYS_ROOT_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
++printf "%s\n" "$MSYS_ROOT_PATH" >&6; }
+     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
+   else
+     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
+   fi
+ 
+   # Test if windows or unix (cygwin/msys) find is first in path.
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
+-$as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
++printf %s "checking what kind of 'find' is first on the PATH... " >&6; }
+   FIND_BINARY_OUTPUT=`find --version 2>&1`
+   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
+-$as_echo "unix style" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
++printf "%s\n" "unix style" >&6; }
+   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
+-$as_echo "Windows" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
+-$as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&5
+-$as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
++printf "%s\n" "Windows" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
++printf "%s\n" "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&5
++printf "%s\n" "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
+     as_fn_error $? "Cannot continue" "$LINENO" 5
+   else
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
+-$as_echo "unknown" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
+-$as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
++printf "%s\n" "unknown" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
++printf "%s\n" "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
+   fi
+ 
+   else
+@@ -14392,10 +15926,10 @@ $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2
+ 
+ 
+   # We get the top-level directory from the supporting wrappers.
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
+-$as_echo_n "checking for top-level directory... " >&6; }
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
+-$as_echo "$TOPDIR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
++printf %s "checking for top-level directory... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
++printf "%s\n" "$TOPDIR" >&6; }
+ 
+ 
+   # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
+@@ -14419,8 +15953,8 @@ $as_echo "$TOPDIR" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
+   fi
+ 
+@@ -14468,8 +16002,8 @@ $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid."
+ 
+   if test "x$path" != "x$new_path"; then
+     CURDIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -14506,8 +16040,8 @@ $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     CURDIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -14518,8 +16052,8 @@ $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
+     path="$CURDIR"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -14552,8 +16086,8 @@ $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid."
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
+   fi
+ 
+@@ -14601,8 +16135,8 @@ $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid."
+ 
+   if test "x$path" != "x$new_path"; then
+     TOPDIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -14639,8 +16173,8 @@ $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     TOPDIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -14651,8 +16185,8 @@ $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
+     path="$TOPDIR"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -14684,34 +16218,36 @@ $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid."
+ # Check if it's a pure open build or if custom sources are to be used.
+ 
+   # Check whether --enable-openjdk-only was given.
+-if test "${enable_openjdk_only+set}" = set; then :
++if test ${enable_openjdk_only+y}
++then :
+   enableval=$enable_openjdk_only;
+-else
+-  enable_openjdk_only="no"
++else case e in #(
++  e) enable_openjdk_only="no" ;;
++esac
+ fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
+-$as_echo_n "checking for presence of closed sources... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
++printf %s "checking for presence of closed sources... " >&6; }
+   if test -d "$SRC_ROOT/jdk/src/closed"; then
+     CLOSED_SOURCE_PRESENT=yes
+   else
+     CLOSED_SOURCE_PRESENT=no
+   fi
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
+-$as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
++printf "%s\n" "$CLOSED_SOURCE_PRESENT" >&6; }
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
+-$as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
++printf %s "checking if closed source is suppressed (openjdk-only)... " >&6; }
+   SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
+-$as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
++printf "%s\n" "$SUPPRESS_CLOSED_SOURCE" >&6; }
+ 
+   if test "x$CLOSED_SOURCE_PRESENT" = xno; then
+     OPENJDK=true
+     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
+-$as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
++printf "%s\n" "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
+     fi
+   else
+     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
+@@ -14741,11 +16277,12 @@ $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes
+   # modules to compile into the JDK. In the future, these modules
+   # might even be Jigsaw modules.
+   #
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
+-$as_echo_n "checking which variant of the JDK to build... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
++printf %s "checking which variant of the JDK to build... " >&6; }
+ 
+ # Check whether --with-jdk-variant was given.
+-if test "${with_jdk_variant+set}" = set; then :
++if test ${with_jdk_variant+y}
++then :
+   withval=$with_jdk_variant;
+ fi
+ 
+@@ -14758,8 +16295,8 @@ fi
+ 
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
+-$as_echo "$JDK_VARIANT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
++printf "%s\n" "$JDK_VARIANT" >&6; }
+ 
+ 
+ ###############################################################################
+@@ -14768,11 +16305,12 @@ $as_echo "$JDK_VARIANT" >&6; }
+ # Currently we have:
+ #    template: Template interpreter (the default)
+ #    cpp     : C++ interpreter
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
+-$as_echo_n "checking which interpreter of the JVM to build... " >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
++printf %s "checking which interpreter of the JVM to build... " >&6; }
+ 
+ # Check whether --with-jvm-interpreter was given.
+-if test "${with_jvm_interpreter+set}" = set; then :
++if test ${with_jvm_interpreter+y}
++then :
+   withval=$with_jvm_interpreter;
+ fi
+ 
+@@ -14789,8 +16327,8 @@ fi
+ 
+ 
+ 
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
+-$as_echo "$with_jvm_interpreter" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
++printf "%s\n" "$with_jvm_interpreter" >&6; }
+ 
+ 
+ 
+@@ -14806,11 +16344,12 @@ $as_echo "$with_jvm_interpreter" >&6; }
+   #    zero: no machine code interpreter, no compiler
+   #    zeroshark: zero interpreter and shark/llvm compiler backend
+ #    core: interpreter only, no compiler (only works on some platforms)
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
+-$as_echo_n "checking which variants of the JVM to build... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
++printf %s "checking which variants of the JVM to build... " >&6; }
+ 
+ # Check whether --with-jvm-variants was given.
+-if test "${with_jvm_variants+set}" = set; then :
++if test ${with_jvm_variants+y}
++then :
+   withval=$with_jvm_variants;
+ fi
+ 
+@@ -14825,8 +16364,8 @@ fi
+   if test "x$TEST_VARIANTS" != "x,"; then
+      as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
+   fi
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
+-$as_echo "$with_jvm_variants" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
++printf "%s\n" "$with_jvm_variants" >&6; }
+ 
+   JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
+   JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
+@@ -14871,6 +16410,9 @@ $as_echo "$with_jvm_variants" >&6; }
+ 
+ 
+   INCLUDE_SA=true
++  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
++    INCLUDE_SA=false
++  fi
+   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
+     INCLUDE_SA=false
+   fi
+@@ -14897,22 +16439,25 @@ $as_echo "$with_jvm_variants" >&6; }
+   #    slowdebug: debug information (-g), no optimizations, all asserts
+   #
+   DEBUG_LEVEL="release"
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
+-$as_echo_n "checking which debug level to use... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
++printf %s "checking which debug level to use... " >&6; }
+   # Check whether --enable-debug was given.
+-if test "${enable_debug+set}" = set; then :
++if test ${enable_debug+y}
++then :
+   enableval=$enable_debug;
+         ENABLE_DEBUG="${enableval}"
+         DEBUG_LEVEL="fastdebug"
+ 
+-else
+-  ENABLE_DEBUG="no"
++else case e in #(
++  e) ENABLE_DEBUG="no" ;;
++esac
+ fi
+ 
+ 
+ 
+ # Check whether --with-debug-level was given.
+-if test "${with_debug_level+set}" = set; then :
++if test ${with_debug_level+y}
++then :
+   withval=$with_debug_level;
+         DEBUG_LEVEL="${withval}"
+         if test "x$ENABLE_DEBUG" = xyes; then
+@@ -14921,8 +16466,8 @@ if test "${with_debug_level+set}" = set; then :
+ 
+ fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
+-$as_echo "$DEBUG_LEVEL" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
++printf "%s\n" "$DEBUG_LEVEL" >&6; }
+ 
+   if test "x$DEBUG_LEVEL" != xrelease && \
+       test "x$DEBUG_LEVEL" != xfastdebug && \
+@@ -15025,7 +16570,8 @@ $as_echo "$DEBUG_LEVEL" >&6; }
+ 
+ 
+ # Check whether --with-devkit was given.
+-if test "${with_devkit+set}" = set; then :
++if test ${with_devkit+y}
++then :
+   withval=$with_devkit;
+ fi
+ 
+@@ -15053,8 +16599,8 @@ fi
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
+   fi
+ 
+@@ -15102,8 +16648,8 @@ $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is inval
+ 
+   if test "x$path" != "x$new_path"; then
+     with_devkit="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -15140,8 +16686,8 @@ $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     with_devkit="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -15152,8 +16698,8 @@ $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
+     path="$with_devkit"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -15240,14 +16786,14 @@ $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is inval
+ 
+     fi
+ 
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
+-$as_echo_n "checking for devkit... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
++printf %s "checking for devkit... " >&6; }
+     if test "x$DEVKIT_NAME" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
+-$as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
++printf "%s\n" "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
+-$as_echo "$DEVKIT_ROOT" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
++printf "%s\n" "$DEVKIT_ROOT" >&6; }
+     fi
+ 
+ 
+@@ -15297,7 +16843,8 @@ $as_echo "$DEVKIT_ROOT" >&6; }
+   # is not correct.
+ 
+ # Check whether --with-sys-root was given.
+-if test "${with_sys_root+set}" = set; then :
++if test ${with_sys_root+y}
++then :
+   withval=$with_sys_root; SYSROOT=$with_sys_root
+ 
+ fi
+@@ -15305,7 +16852,8 @@ fi
+ 
+ 
+ # Check whether --with-sysroot was given.
+-if test "${with_sysroot+set}" = set; then :
++if test ${with_sysroot+y}
++then :
+   withval=$with_sysroot; SYSROOT=$with_sysroot
+ 
+ fi
+@@ -15313,7 +16861,8 @@ fi
+ 
+ 
+ # Check whether --with-tools-dir was given.
+-if test "${with_tools_dir+set}" = set; then :
++if test ${with_tools_dir+y}
++then :
+   withval=$with_tools_dir;
+   if test "x$with_tools_dir" != x; then
+     if test "x$TOOLCHAIN_PATH" = x; then
+@@ -15329,7 +16878,8 @@ fi
+ 
+ 
+ # Check whether --with-toolchain-path was given.
+-if test "${with_toolchain_path+set}" = set; then :
++if test ${with_toolchain_path+y}
++then :
+   withval=$with_toolchain_path;
+   if test "x$with_toolchain_path" != x; then
+     if test "x$TOOLCHAIN_PATH" = x; then
+@@ -15345,7 +16895,8 @@ fi
+ 
+ 
+ # Check whether --with-extra-path was given.
+-if test "${with_extra_path+set}" = set; then :
++if test ${with_extra_path+y}
++then :
+   withval=$with_extra_path;
+   if test "x$with_extra_path" != x; then
+     if test "x$EXTRA_PATH" = x; then
+@@ -15378,24 +16929,25 @@ fi
+   # Xcode version will be validated later
+ 
+ # Check whether --with-xcode-path was given.
+-if test "${with_xcode_path+set}" = set; then :
++if test ${with_xcode_path+y}
++then :
+   withval=$with_xcode_path; XCODE_PATH=$with_xcode_path
+ 
+ fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
+-$as_echo_n "checking for sysroot... " >&6; }
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
+-$as_echo "$SYSROOT" >&6; }
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
+-$as_echo_n "checking for toolchain path... " >&6; }
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
+-$as_echo "$TOOLCHAIN_PATH" >&6; }
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
+-$as_echo_n "checking for extra path... " >&6; }
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
+-$as_echo "$EXTRA_PATH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
++printf %s "checking for sysroot... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
++printf "%s\n" "$SYSROOT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
++printf %s "checking for toolchain path... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
++printf "%s\n" "$TOOLCHAIN_PATH" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
++printf %s "checking for extra path... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
++printf "%s\n" "$EXTRA_PATH" >&6; }
+ 
+ 
+ # To properly create a configuration name, we need to have the OpenJDK target
+@@ -15404,26 +16956,27 @@ $as_echo "$EXTRA_PATH" >&6; }
+ 
+ 
+ # Check whether --with-conf-name was given.
+-if test "${with_conf_name+set}" = set; then :
++if test ${with_conf_name+y}
++then :
+   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
+ fi
+ 
+ 
+   # Test from where we are running configure, in or outside of src root.
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
+-$as_echo_n "checking where to store configuration... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
++printf %s "checking where to store configuration... " >&6; }
+   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
+       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
+       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
+     # We are running configure from the src root.
+     # Create a default ./build/target-variant-debuglevel output root.
+     if test "x${CONF_NAME}" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
+-$as_echo "in default location" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
++printf "%s\n" "in default location" >&6; }
+       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
+-$as_echo "in build directory with custom name" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
++printf "%s\n" "in build directory with custom name" >&6; }
+     fi
+     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
+     $MKDIR -p "$OUTPUT_ROOT"
+@@ -15439,8 +16992,8 @@ $as_echo "in build directory with custom name" >&6; }
+       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
+     fi
+     OUTPUT_ROOT="$CURDIR"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
+-$as_echo "in current directory" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
++printf "%s\n" "in current directory" >&6; }
+ 
+     # WARNING: This might be a bad thing to do. You need to be sure you want to
+     # have a configuration in this directory. Do some sanity checks!
+@@ -15458,28 +17011,28 @@ $as_echo "in current directory" >&6; }
+               -e 's/ //g' \
+           | $TR -d '\n'`
+       if test "x$filtered_files" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
+-$as_echo "$as_me: Current directory is $CURDIR." >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
+-$as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
+-$as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
+-$as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
+-$as_echo "$as_me: seriously mess up just about everything." >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
+-$as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
+-$as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
++printf "%s\n" "$as_me: Current directory is $CURDIR." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
++printf "%s\n" "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
++printf "%s\n" "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
++printf "%s\n" "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
++printf "%s\n" "$as_me: seriously mess up just about everything." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
++printf "%s\n" "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
++printf "%s\n" "$as_me: (or create a new empty directory and cd to it)." >&6;}
+         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
+       fi
+     fi
+   fi
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
+-$as_echo_n "checking what configuration name to use... " >&6; }
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
+-$as_echo "$CONF_NAME" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
++printf %s "checking what configuration name to use... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
++printf "%s\n" "$CONF_NAME" >&6; }
+ 
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -15501,8 +17054,8 @@ $as_echo "$CONF_NAME" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
+   fi
+ 
+@@ -15550,8 +17103,8 @@ $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is inval
+ 
+   if test "x$path" != "x$new_path"; then
+     OUTPUT_ROOT="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -15588,8 +17141,8 @@ $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     OUTPUT_ROOT="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -15600,8 +17153,8 @@ $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
+     path="$OUTPUT_ROOT"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -15653,38 +17206,44 @@ $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is inval
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_PKGHANDLER+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$PKGHANDLER"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_PKGHANDLER+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$PKGHANDLER"; then
+   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_PKGHANDLER="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ PKGHANDLER=$ac_cv_prog_PKGHANDLER
+ if test -n "$PKGHANDLER"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
+-$as_echo "$PKGHANDLER" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
++printf "%s\n" "$PKGHANDLER" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -15706,18 +17265,18 @@ done
+   MAKE_CANDIDATE=""$MAKE""
+   DESCRIPTION="user supplied MAKE=$MAKE"
+   if test "x$MAKE_CANDIDATE" != x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
+-$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
++printf "%s\n" "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
+     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
+     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
+     if test "x$IS_GNU_MAKE" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
+-$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
++printf "%s\n" "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
+     else
+       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
+       if test "x$IS_MODERN_MAKE" = x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
+-$as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
++printf "%s\n" "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
+       else
+         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
+           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -15734,8 +17293,8 @@ $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version
+           IS_MAKE_CORRECT_ENV=true
+         fi
+         if test "x$IS_MAKE_CORRECT_ENV" = x; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
+-$as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
++printf "%s\n" "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
+         else
+           FOUND_MAKE=$MAKE_CANDIDATE
+ 
+@@ -15779,12 +17338,12 @@ $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -15806,10 +17365,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+   else
+@@ -15919,12 +17478,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -15996,12 +17555,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -16016,8 +17575,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     FOUND_MAKE="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
+   fi
+ 
+         fi
+@@ -16034,12 +17593,13 @@ $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CHECK_GMAKE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CHECK_GMAKE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CHECK_GMAKE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CHECK_GMAKE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
+   ;;
+@@ -16048,11 +17608,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CHECK_GMAKE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -16060,15 +17624,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
+ if test -n "$CHECK_GMAKE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
+-$as_echo "$CHECK_GMAKE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
++printf "%s\n" "$CHECK_GMAKE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -16079,18 +17644,18 @@ done
+   MAKE_CANDIDATE=""$CHECK_GMAKE""
+   DESCRIPTION="gmake in PATH"
+   if test "x$MAKE_CANDIDATE" != x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
+-$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
++printf "%s\n" "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
+     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
+     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
+     if test "x$IS_GNU_MAKE" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
+-$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
++printf "%s\n" "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
+     else
+       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
+       if test "x$IS_MODERN_MAKE" = x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
+-$as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
++printf "%s\n" "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
+       else
+         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
+           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -16107,8 +17672,8 @@ $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version
+           IS_MAKE_CORRECT_ENV=true
+         fi
+         if test "x$IS_MAKE_CORRECT_ENV" = x; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
+-$as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
++printf "%s\n" "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
+         else
+           FOUND_MAKE=$MAKE_CANDIDATE
+ 
+@@ -16152,12 +17717,12 @@ $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -16179,10 +17744,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+   else
+@@ -16292,12 +17857,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -16369,12 +17934,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -16389,8 +17954,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     FOUND_MAKE="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
+   fi
+ 
+         fi
+@@ -16404,12 +17969,13 @@ $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CHECK_MAKE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CHECK_MAKE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CHECK_MAKE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CHECK_MAKE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
+   ;;
+@@ -16418,11 +17984,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CHECK_MAKE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -16430,15 +18000,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CHECK_MAKE=$ac_cv_path_CHECK_MAKE
+ if test -n "$CHECK_MAKE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
+-$as_echo "$CHECK_MAKE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
++printf "%s\n" "$CHECK_MAKE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -16449,18 +18020,18 @@ done
+   MAKE_CANDIDATE=""$CHECK_MAKE""
+   DESCRIPTION="make in PATH"
+   if test "x$MAKE_CANDIDATE" != x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
+-$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
++printf "%s\n" "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
+     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
+     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
+     if test "x$IS_GNU_MAKE" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
+-$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
++printf "%s\n" "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
+     else
+       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
+       if test "x$IS_MODERN_MAKE" = x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
+-$as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
++printf "%s\n" "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
+       else
+         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
+           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -16477,8 +18048,8 @@ $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version
+           IS_MAKE_CORRECT_ENV=true
+         fi
+         if test "x$IS_MAKE_CORRECT_ENV" = x; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
+-$as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
++printf "%s\n" "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
+         else
+           FOUND_MAKE=$MAKE_CANDIDATE
+ 
+@@ -16522,12 +18093,12 @@ $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -16549,10 +18120,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+   else
+@@ -16662,12 +18233,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -16739,12 +18310,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -16759,8 +18330,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     FOUND_MAKE="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
+   fi
+ 
+         fi
+@@ -16779,12 +18350,13 @@ $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CHECK_TOOLSDIR_GMAKE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CHECK_TOOLSDIR_GMAKE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
+   ;;
+@@ -16793,11 +18365,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -16805,15 +18381,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
+ if test -n "$CHECK_TOOLSDIR_GMAKE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
+-$as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
++printf "%s\n" "$CHECK_TOOLSDIR_GMAKE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -16824,18 +18401,18 @@ done
+   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
+   DESCRIPTION="gmake in tools-dir"
+   if test "x$MAKE_CANDIDATE" != x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
+-$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
++printf "%s\n" "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
+     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
+     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
+     if test "x$IS_GNU_MAKE" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
+-$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
++printf "%s\n" "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
+     else
+       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
+       if test "x$IS_MODERN_MAKE" = x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
+-$as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
++printf "%s\n" "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
+       else
+         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
+           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -16852,8 +18429,8 @@ $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version
+           IS_MAKE_CORRECT_ENV=true
+         fi
+         if test "x$IS_MAKE_CORRECT_ENV" = x; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
+-$as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
++printf "%s\n" "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
+         else
+           FOUND_MAKE=$MAKE_CANDIDATE
+ 
+@@ -16897,12 +18474,12 @@ $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -16924,10 +18501,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+   else
+@@ -17037,12 +18614,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -17114,12 +18691,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -17134,8 +18711,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     FOUND_MAKE="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
+   fi
+ 
+         fi
+@@ -17148,12 +18725,13 @@ $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CHECK_TOOLSDIR_MAKE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CHECK_TOOLSDIR_MAKE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CHECK_TOOLSDIR_MAKE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
+   ;;
+@@ -17162,11 +18740,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -17174,15 +18756,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
+ if test -n "$CHECK_TOOLSDIR_MAKE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
+-$as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
++printf "%s\n" "$CHECK_TOOLSDIR_MAKE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -17193,18 +18776,18 @@ done
+   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
+   DESCRIPTION="make in tools-dir"
+   if test "x$MAKE_CANDIDATE" != x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
+-$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
++printf "%s\n" "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
+     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
+     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
+     if test "x$IS_GNU_MAKE" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
+-$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
++printf "%s\n" "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
+     else
+       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
+       if test "x$IS_MODERN_MAKE" = x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
+-$as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
++printf "%s\n" "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
+       else
+         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
+           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -17221,8 +18804,8 @@ $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version
+           IS_MAKE_CORRECT_ENV=true
+         fi
+         if test "x$IS_MAKE_CORRECT_ENV" = x; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
+-$as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
++printf "%s\n" "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
+         else
+           FOUND_MAKE=$MAKE_CANDIDATE
+ 
+@@ -17266,12 +18849,12 @@ $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -17293,10 +18876,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+   else
+@@ -17406,12 +18989,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -17483,12 +19066,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
+     fi
+@@ -17503,8 +19086,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     FOUND_MAKE="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
+   fi
+ 
+         fi
+@@ -17524,14 +19107,14 @@ $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
+ 
+   MAKE=$FOUND_MAKE
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
+-$as_echo "$as_me: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
++printf "%s\n" "$as_me: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
+ 
+ 
+ 
+   # Test if find supports -delete
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
+-$as_echo_n "checking if find supports -delete... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
++printf %s "checking if find supports -delete... " >&6; }
+   FIND_DELETE="-delete"
+ 
+   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
+@@ -17543,11 +19126,11 @@ $as_echo_n "checking if find supports -delete... " >&6; }
+     # No, it does not.
+     rm $DELETEDIR/TestIfFindSupportsDelete
+     FIND_DELETE="-exec rm \{\} \+"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+   else
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+   fi
+   rmdir $DELETEDIR
+ 
+@@ -17567,12 +19150,13 @@ $as_echo "yes" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_UNZIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $UNZIP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_UNZIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $UNZIP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
+   ;;
+@@ -17581,11 +19165,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_UNZIP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -17593,15 +19181,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ UNZIP=$ac_cv_path_UNZIP
+ if test -n "$UNZIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
+-$as_echo "$UNZIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
++printf "%s\n" "$UNZIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -17617,20 +19206,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xUNZIP" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in unzip
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_UNZIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $UNZIP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_UNZIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $UNZIP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
+   ;;
+@@ -17639,11 +19229,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_UNZIP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -17651,15 +19245,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ UNZIP=$ac_cv_path_UNZIP
+ if test -n "$UNZIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
+-$as_echo "$UNZIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
++printf "%s\n" "$UNZIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -17679,16 +19274,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_UNZIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $UNZIP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_UNZIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $UNZIP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
+   ;;
+@@ -17697,11 +19293,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_UNZIP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -17709,15 +19309,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ UNZIP=$ac_cv_path_UNZIP
+ if test -n "$UNZIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
+-$as_echo "$UNZIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
++printf "%s\n" "$UNZIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -17726,17 +19327,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
+-$as_echo_n "checking for UNZIP... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
++printf %s "checking for UNZIP... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -17760,12 +19361,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_ZIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $ZIP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_ZIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $ZIP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
+   ;;
+@@ -17774,11 +19376,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_ZIP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -17786,15 +19392,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ ZIP=$ac_cv_path_ZIP
+ if test -n "$ZIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
+-$as_echo "$ZIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
++printf "%s\n" "$ZIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -17810,20 +19417,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xZIP" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in zip
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_ZIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $ZIP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_ZIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $ZIP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
+   ;;
+@@ -17832,11 +19440,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_ZIP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -17844,15 +19456,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ ZIP=$ac_cv_path_ZIP
+ if test -n "$ZIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
+-$as_echo "$ZIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
++printf "%s\n" "$ZIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -17872,16 +19485,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_ZIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $ZIP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_ZIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $ZIP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
+   ;;
+@@ -17890,11 +19504,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_ZIP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -17902,15 +19520,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ ZIP=$ac_cv_path_ZIP
+ if test -n "$ZIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
+-$as_echo "$ZIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
++printf "%s\n" "$ZIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -17919,17 +19538,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
+-$as_echo_n "checking for ZIP... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
++printf %s "checking for ZIP... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -17955,12 +19574,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_LDD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $LDD in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_LDD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $LDD in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
+   ;;
+@@ -17969,11 +19589,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_LDD="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -17981,15 +19605,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ LDD=$ac_cv_path_LDD
+ if test -n "$LDD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
+-$as_echo "$LDD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
++printf "%s\n" "$LDD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18005,20 +19630,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xLDD" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in ldd
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_LDD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $LDD in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_LDD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $LDD in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
+   ;;
+@@ -18027,11 +19653,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_LDD="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18039,15 +19669,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ LDD=$ac_cv_path_LDD
+ if test -n "$LDD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
+-$as_echo "$LDD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
++printf "%s\n" "$LDD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18067,16 +19698,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_LDD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $LDD in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_LDD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $LDD in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
+   ;;
+@@ -18085,11 +19717,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_LDD="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18097,15 +19733,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ LDD=$ac_cv_path_LDD
+ if test -n "$LDD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
+-$as_echo "$LDD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
++printf "%s\n" "$LDD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18114,17 +19751,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
+-$as_echo_n "checking for LDD... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
++printf %s "checking for LDD... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -18147,12 +19784,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_READELF+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $READELF in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_READELF+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $READELF in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
+   ;;
+@@ -18161,11 +19799,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_READELF="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18173,15 +19815,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ READELF=$ac_cv_path_READELF
+ if test -n "$READELF"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
+-$as_echo "$READELF" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
++printf "%s\n" "$READELF" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18197,20 +19840,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xREADELF" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in readelf greadelf
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_READELF+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $READELF in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_READELF+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $READELF in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
+   ;;
+@@ -18219,11 +19863,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_READELF="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18231,15 +19879,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ READELF=$ac_cv_path_READELF
+ if test -n "$READELF"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
+-$as_echo "$READELF" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
++printf "%s\n" "$READELF" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18259,16 +19908,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_READELF+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $READELF in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_READELF+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $READELF in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
+   ;;
+@@ -18277,11 +19927,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_READELF="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18289,15 +19943,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ READELF=$ac_cv_path_READELF
+ if test -n "$READELF"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
+-$as_echo "$READELF" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
++printf "%s\n" "$READELF" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18306,17 +19961,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
+-$as_echo_n "checking for READELF... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
++printf %s "checking for READELF... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -18333,12 +19988,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_HG+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $HG in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_HG+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $HG in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_HG="$HG" # Let the user override the test with a path.
+   ;;
+@@ -18347,11 +20003,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_HG="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18359,15 +20019,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ HG=$ac_cv_path_HG
+ if test -n "$HG"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
+-$as_echo "$HG" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
++printf "%s\n" "$HG" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18383,20 +20044,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xHG" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in hg
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_HG+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $HG in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_HG+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $HG in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_HG="$HG" # Let the user override the test with a path.
+   ;;
+@@ -18405,11 +20067,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_HG="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18417,15 +20083,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ HG=$ac_cv_path_HG
+ if test -n "$HG"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
+-$as_echo "$HG" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
++printf "%s\n" "$HG" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18445,16 +20112,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_HG+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $HG in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_HG+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $HG in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_HG="$HG" # Let the user override the test with a path.
+   ;;
+@@ -18463,11 +20131,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_HG="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18475,15 +20147,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ HG=$ac_cv_path_HG
+ if test -n "$HG"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
+-$as_echo "$HG" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
++printf "%s\n" "$HG" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18492,17 +20165,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
+-$as_echo_n "checking for HG... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
++printf %s "checking for HG... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -18519,12 +20192,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_GIT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $GIT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_GIT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $GIT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_GIT="$GIT" # Let the user override the test with a path.
+   ;;
+@@ -18533,11 +20207,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_GIT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_GIT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18545,15 +20223,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ GIT=$ac_cv_path_GIT
+ if test -n "$GIT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GIT" >&5
+-$as_echo "$GIT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GIT" >&5
++printf "%s\n" "$GIT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18569,20 +20248,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xGIT" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GIT from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of GIT from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GIT from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of GIT from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in git
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_GIT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $GIT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_GIT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $GIT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_GIT="$GIT" # Let the user override the test with a path.
+   ;;
+@@ -18591,11 +20271,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_GIT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_GIT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18603,15 +20287,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ GIT=$ac_cv_path_GIT
+ if test -n "$GIT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GIT" >&5
+-$as_echo "$GIT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GIT" >&5
++printf "%s\n" "$GIT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18631,16 +20316,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GIT=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool GIT=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GIT=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool GIT=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_GIT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $GIT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_GIT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $GIT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_GIT="$GIT" # Let the user override the test with a path.
+   ;;
+@@ -18649,11 +20335,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_GIT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_GIT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18661,15 +20351,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ GIT=$ac_cv_path_GIT
+ if test -n "$GIT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GIT" >&5
+-$as_echo "$GIT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GIT" >&5
++printf "%s\n" "$GIT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18678,17 +20369,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GIT=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool GIT=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GIT" >&5
+-$as_echo_n "checking for GIT... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GIT=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool GIT=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GIT" >&5
++printf %s "checking for GIT... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool GIT=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -18705,12 +20396,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_STAT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $STAT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_STAT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $STAT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
+   ;;
+@@ -18719,11 +20411,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_STAT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18731,15 +20427,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ STAT=$ac_cv_path_STAT
+ if test -n "$STAT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
+-$as_echo "$STAT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
++printf "%s\n" "$STAT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18755,20 +20452,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xSTAT" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in stat
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_STAT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $STAT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_STAT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $STAT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
+   ;;
+@@ -18777,11 +20475,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_STAT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18789,15 +20491,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ STAT=$ac_cv_path_STAT
+ if test -n "$STAT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
+-$as_echo "$STAT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
++printf "%s\n" "$STAT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18817,16 +20520,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_STAT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $STAT in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_STAT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $STAT in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
+   ;;
+@@ -18835,11 +20539,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_STAT="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18847,15 +20555,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ STAT=$ac_cv_path_STAT
+ if test -n "$STAT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
+-$as_echo "$STAT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
++printf "%s\n" "$STAT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18864,17 +20573,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
+-$as_echo_n "checking for STAT... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
++printf %s "checking for STAT... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -18891,12 +20600,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TIME+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TIME in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TIME+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TIME in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
+   ;;
+@@ -18905,11 +20615,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TIME="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18917,15 +20631,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TIME=$ac_cv_path_TIME
+ if test -n "$TIME"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
+-$as_echo "$TIME" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
++printf "%s\n" "$TIME" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -18941,20 +20656,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xTIME" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in time
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TIME+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TIME in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TIME+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TIME in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
+   ;;
+@@ -18963,11 +20679,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TIME="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -18975,15 +20695,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TIME=$ac_cv_path_TIME
+ if test -n "$TIME"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
+-$as_echo "$TIME" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
++printf "%s\n" "$TIME" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19003,16 +20724,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TIME+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TIME in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TIME+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TIME in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
+   ;;
+@@ -19021,11 +20743,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TIME="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19033,15 +20759,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TIME=$ac_cv_path_TIME
+ if test -n "$TIME"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
+-$as_echo "$TIME" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
++printf "%s\n" "$TIME" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19050,17 +20777,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
+-$as_echo_n "checking for TIME... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
++printf %s "checking for TIME... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -19088,12 +20815,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_COMM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $COMM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_COMM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $COMM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
+   ;;
+@@ -19102,11 +20830,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_COMM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19114,15 +20846,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ COMM=$ac_cv_path_COMM
+ if test -n "$COMM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
+-$as_echo "$COMM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
++printf "%s\n" "$COMM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19138,20 +20871,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xCOMM" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in comm
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_COMM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $COMM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_COMM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $COMM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
+   ;;
+@@ -19160,11 +20894,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_COMM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19172,15 +20910,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ COMM=$ac_cv_path_COMM
+ if test -n "$COMM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
+-$as_echo "$COMM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
++printf "%s\n" "$COMM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19200,16 +20939,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_COMM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $COMM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_COMM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $COMM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
+   ;;
+@@ -19218,11 +20958,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_COMM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19230,15 +20974,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ COMM=$ac_cv_path_COMM
+ if test -n "$COMM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
+-$as_echo "$COMM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
++printf "%s\n" "$COMM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19247,17 +20992,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
+-$as_echo_n "checking for COMM... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
++printf %s "checking for COMM... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -19284,12 +21029,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DSYMUTIL+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DSYMUTIL in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DSYMUTIL+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DSYMUTIL in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
+   ;;
+@@ -19298,11 +21044,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DSYMUTIL="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19310,15 +21060,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DSYMUTIL=$ac_cv_path_DSYMUTIL
+ if test -n "$DSYMUTIL"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
+-$as_echo "$DSYMUTIL" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
++printf "%s\n" "$DSYMUTIL" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19334,20 +21085,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xDSYMUTIL" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in dsymutil
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DSYMUTIL+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DSYMUTIL in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DSYMUTIL+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DSYMUTIL in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
+   ;;
+@@ -19356,11 +21108,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DSYMUTIL="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19368,15 +21124,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DSYMUTIL=$ac_cv_path_DSYMUTIL
+ if test -n "$DSYMUTIL"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
+-$as_echo "$DSYMUTIL" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
++printf "%s\n" "$DSYMUTIL" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19396,16 +21153,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_DSYMUTIL+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $DSYMUTIL in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_DSYMUTIL+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $DSYMUTIL in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
+   ;;
+@@ -19414,11 +21172,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_DSYMUTIL="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19426,15 +21188,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ DSYMUTIL=$ac_cv_path_DSYMUTIL
+ if test -n "$DSYMUTIL"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
+-$as_echo "$DSYMUTIL" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
++printf "%s\n" "$DSYMUTIL" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19443,17 +21206,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
+-$as_echo_n "checking for DSYMUTIL... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
++printf %s "checking for DSYMUTIL... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -19477,12 +21240,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_XATTR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $XATTR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_XATTR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $XATTR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
+   ;;
+@@ -19491,11 +21255,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_XATTR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19503,15 +21271,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ XATTR=$ac_cv_path_XATTR
+ if test -n "$XATTR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
+-$as_echo "$XATTR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
++printf "%s\n" "$XATTR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19527,20 +21296,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xXATTR" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in xattr
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_XATTR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $XATTR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_XATTR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $XATTR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
+   ;;
+@@ -19549,11 +21319,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_XATTR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19561,15 +21335,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ XATTR=$ac_cv_path_XATTR
+ if test -n "$XATTR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
+-$as_echo "$XATTR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
++printf "%s\n" "$XATTR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19589,16 +21364,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_XATTR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $XATTR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_XATTR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $XATTR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
+   ;;
+@@ -19607,11 +21383,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_XATTR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19619,15 +21399,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ XATTR=$ac_cv_path_XATTR
+ if test -n "$XATTR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
+-$as_echo "$XATTR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
++printf "%s\n" "$XATTR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19636,17 +21417,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
+-$as_echo_n "checking for XATTR... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
++printf %s "checking for XATTR... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -19669,12 +21450,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CODESIGN+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CODESIGN in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CODESIGN+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CODESIGN in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
+   ;;
+@@ -19683,11 +21465,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CODESIGN="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19695,15 +21481,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CODESIGN=$ac_cv_path_CODESIGN
+ if test -n "$CODESIGN"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
+-$as_echo "$CODESIGN" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
++printf "%s\n" "$CODESIGN" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19719,20 +21506,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xCODESIGN" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in codesign
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CODESIGN+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CODESIGN in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CODESIGN+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CODESIGN in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
+   ;;
+@@ -19741,11 +21529,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CODESIGN="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19753,15 +21545,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CODESIGN=$ac_cv_path_CODESIGN
+ if test -n "$CODESIGN"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
+-$as_echo "$CODESIGN" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
++printf "%s\n" "$CODESIGN" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19781,16 +21574,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CODESIGN+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CODESIGN in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CODESIGN+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CODESIGN in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
+   ;;
+@@ -19799,11 +21593,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CODESIGN="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19811,15 +21609,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CODESIGN=$ac_cv_path_CODESIGN
+ if test -n "$CODESIGN"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
+-$as_echo "$CODESIGN" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
++printf "%s\n" "$CODESIGN" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19828,17 +21627,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
+-$as_echo_n "checking for CODESIGN... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
++printf %s "checking for CODESIGN... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -19846,18 +21645,18 @@ $as_echo "$tool_specified" >&6; }
+ 
+     if test "x$CODESIGN" != "x"; then
+       # Verify that the openjdk_codesign certificate is present
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
+-$as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
++printf %s "checking if openjdk_codesign certificate is present... " >&6; }
+       rm -f codesign-testfile
+       touch codesign-testfile
+       codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
+       rm -f codesign-testfile
+       if test "x$CODESIGN" = x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+       else
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+       fi
+     fi
+   fi
+@@ -19870,12 +21669,13 @@ if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
+ 	if test -n "$ac_tool_prefix"; then
+   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
+ set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_PKG_CONFIG+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $PKG_CONFIG in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_PKG_CONFIG+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $PKG_CONFIG in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
+   ;;
+@@ -19884,11 +21684,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_PKG_CONFIG="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19896,15 +21700,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ PKG_CONFIG=$ac_cv_path_PKG_CONFIG
+ if test -n "$PKG_CONFIG"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
+-$as_echo "$PKG_CONFIG" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
++printf "%s\n" "$PKG_CONFIG" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -19913,12 +21718,13 @@ if test -z "$ac_cv_path_PKG_CONFIG"; then
+   ac_pt_PKG_CONFIG=$PKG_CONFIG
+   # Extract the first word of "pkg-config", so it can be a program name with args.
+ set dummy pkg-config; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $ac_pt_PKG_CONFIG in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_ac_pt_PKG_CONFIG+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $ac_pt_PKG_CONFIG in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
+   ;;
+@@ -19927,11 +21733,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_ac_pt_PKG_CONFIG="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -19939,15 +21749,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
+ if test -n "$ac_pt_PKG_CONFIG"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
+-$as_echo "$ac_pt_PKG_CONFIG" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
++printf "%s\n" "$ac_pt_PKG_CONFIG" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+   if test "x$ac_pt_PKG_CONFIG" = x; then
+@@ -19955,8 +21766,8 @@ fi
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     PKG_CONFIG=$ac_pt_PKG_CONFIG
+@@ -19968,14 +21779,14 @@ fi
+ fi
+ if test -n "$PKG_CONFIG"; then
+ 	_pkg_min_version=0.9.0
+-	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
+-$as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
++	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
++printf %s "checking pkg-config is at least version $_pkg_min_version... " >&6; }
+ 	if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
+-		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++		{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+ 	else
+-		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++		{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ 		PKG_CONFIG=""
+ 	fi
+ 
+@@ -20002,30 +21813,35 @@ fi
+ 
+ 
+ # Check whether --with-builddeps-conf was given.
+-if test "${with_builddeps_conf+set}" = set; then :
++if test ${with_builddeps_conf+y}
++then :
+   withval=$with_builddeps_conf;
+ fi
+ 
+ 
+ 
+ # Check whether --with-builddeps-server was given.
+-if test "${with_builddeps_server+set}" = set; then :
++if test ${with_builddeps_server+y}
++then :
+   withval=$with_builddeps_server;
+ fi
+ 
+ 
+ 
+ # Check whether --with-builddeps-dir was given.
+-if test "${with_builddeps_dir+set}" = set; then :
++if test ${with_builddeps_dir+y}
++then :
+   withval=$with_builddeps_dir;
+-else
+-  with_builddeps_dir=/localhome/builddeps
++else case e in #(
++  e) with_builddeps_dir=/localhome/builddeps ;;
++esac
+ fi
+ 
+ 
+ 
+ # Check whether --with-builddeps-group was given.
+-if test "${with_builddeps_group+set}" = set; then :
++if test ${with_builddeps_group+y}
++then :
+   withval=$with_builddeps_group;
+ fi
+ 
+@@ -20034,19 +21850,19 @@ fi
+ 
+   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
+     if test "x$with_builddeps_conf" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5
+-$as_echo_n "checking for supplied builddeps configuration file... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5
++printf %s "checking for supplied builddeps configuration file... " >&6; }
+       builddepsfile=$with_builddeps_conf
+       if test -s $builddepsfile; then
+         . $builddepsfile
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5
+-$as_echo "loaded!" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5
++printf "%s\n" "loaded!" >&6; }
+       else
+         as_fn_error $? "The given builddeps conf file $with_builddeps_conf could not be loaded!" "$LINENO" 5
+       fi
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5
+-$as_echo_n "checking for builddeps.conf files in sources...... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5
++printf %s "checking for builddeps.conf files in sources...... " >&6; }
+       builddepsfile=`mktemp`
+       touch $builddepsfile
+       # Put all found confs into a single file.
+@@ -20054,8 +21870,8 @@ $as_echo_n "checking for builddeps.conf files in sources...... " >&6; }
+       # Source the file to acquire the variables
+       if test -s $builddepsfile; then
+         . $builddepsfile
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5
+-$as_echo "found at least one!" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5
++printf "%s\n" "found at least one!" >&6; }
+       else
+         as_fn_error $? "Could not find any builddeps.conf at all!" "$LINENO" 5
+       fi
+@@ -20086,38 +21902,44 @@ $as_echo "found at least one!" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_BDEPS_UNZIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$BDEPS_UNZIP"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_BDEPS_UNZIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$BDEPS_UNZIP"; then
+   ac_cv_prog_BDEPS_UNZIP="$BDEPS_UNZIP" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_BDEPS_UNZIP="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ BDEPS_UNZIP=$ac_cv_prog_BDEPS_UNZIP
+ if test -n "$BDEPS_UNZIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5
+-$as_echo "$BDEPS_UNZIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5
++printf "%s\n" "$BDEPS_UNZIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -20132,38 +21954,44 @@ done
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_BDEPS_FTP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$BDEPS_FTP"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_BDEPS_FTP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$BDEPS_FTP"; then
+   ac_cv_prog_BDEPS_FTP="$BDEPS_FTP" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_BDEPS_FTP="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ BDEPS_FTP=$ac_cv_prog_BDEPS_FTP
+ if test -n "$BDEPS_FTP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5
+-$as_echo "$BDEPS_FTP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5
++printf "%s\n" "$BDEPS_FTP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -20186,13 +22014,15 @@ done
+   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
+   # We always build headless support.
+   #
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
+-$as_echo_n "checking headful support... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
++printf %s "checking headful support... " >&6; }
+   # Check whether --enable-headful was given.
+-if test "${enable_headful+set}" = set; then :
++if test ${enable_headful+y}
++then :
+   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
+-else
+-  SUPPORT_HEADFUL=yes
++else case e in #(
++  e) SUPPORT_HEADFUL=yes ;;
++esac
+ fi
+ 
+ 
+@@ -20210,8 +22040,8 @@ fi
+     headful_msg="headless only"
+   fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
+-$as_echo "$headful_msg" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
++printf "%s\n" "$headful_msg" >&6; }
+ 
+ 
+ 
+@@ -20219,10 +22049,12 @@ $as_echo "$headful_msg" >&6; }
+ 
+   # Control wether Hotspot runs Queens test after build.
+   # Check whether --enable-hotspot-test-in-build was given.
+-if test "${enable_hotspot_test_in_build+set}" = set; then :
++if test ${enable_hotspot_test_in_build+y}
++then :
+   enableval=$enable_hotspot_test_in_build;
+-else
+-  enable_hotspot_test_in_build=no
++else case e in #(
++  e) enable_hotspot_test_in_build=no ;;
++esac
+ fi
+ 
+   if test "x$enable_hotspot_test_in_build" = "xyes"; then
+@@ -20238,7 +22070,8 @@ fi
+   #
+ 
+ # Check whether --with-cacerts-file was given.
+-if test "${with_cacerts_file+set}" = set; then :
++if test ${with_cacerts_file+y}
++then :
+   withval=$with_cacerts_file;
+ fi
+ 
+@@ -20252,10 +22085,12 @@ fi
+   # Enable or disable unlimited crypto
+   #
+   # Check whether --enable-unlimited-crypto was given.
+-if test "${enable_unlimited_crypto+set}" = set; then :
++if test ${enable_unlimited_crypto+y}
++then :
+   enableval=$enable_unlimited_crypto;
+-else
+-  enable_unlimited_crypto=no
++else case e in #(
++  e) enable_unlimited_crypto=no ;;
++esac
+ fi
+ 
+   if test "x$enable_unlimited_crypto" = "xyes"; then
+@@ -20283,13 +22118,15 @@ fi
+   #
+   # Enable or disable JFR
+   #
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build JFR" >&5
+-$as_echo_n "checking whether to build JFR... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build JFR" >&5
++printf %s "checking whether to build JFR... " >&6; }
+   # Check whether --enable-jfr was given.
+-if test "${enable_jfr+set}" = set; then :
++if test ${enable_jfr+y}
++then :
+   enableval=$enable_jfr;
+-else
+-  enable_jfr=auto
++else case e in #(
++  e) enable_jfr=auto ;;
++esac
+ fi
+ 
+   if test "x$enable_jfr" = "xno"; then
+@@ -20313,8 +22150,8 @@ fi
+   else
+     as_fn_error $? "--enable-jfr must be set to either yes or no" "$LINENO" 5
+   fi
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_JFR" >&5
+-$as_echo "$ENABLE_JFR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ENABLE_JFR" >&5
++printf "%s\n" "$ENABLE_JFR" >&6; }
+ 
+ 
+ 
+@@ -20324,7 +22161,8 @@ $as_echo "$ENABLE_JFR" >&6; }
+   # Get the settings from parameters
+ 
+ # Check whether --with-milestone was given.
+-if test "${with_milestone+set}" = set; then :
++if test ${with_milestone+y}
++then :
+   withval=$with_milestone;
+ fi
+ 
+@@ -20339,7 +22177,8 @@ fi
+ 
+ 
+ # Check whether --with-update-version was given.
+-if test "${with_update_version+set}" = set; then :
++if test ${with_update_version+y}
++then :
+   withval=$with_update_version;
+ fi
+ 
+@@ -20357,7 +22196,8 @@ fi
+ 
+ 
+ # Check whether --with-user-release-suffix was given.
+-if test "${with_user_release_suffix+set}" = set; then :
++if test ${with_user_release_suffix+y}
++then :
+   withval=$with_user_release_suffix;
+ fi
+ 
+@@ -20369,7 +22209,8 @@ fi
+ 
+ 
+ # Check whether --with-build-number was given.
+-if test "${with_build_number+set}" = set; then :
++if test ${with_build_number+y}
++then :
+   withval=$with_build_number;
+ fi
+ 
+@@ -20404,10 +22245,28 @@ fi
+ 
+ 
+ 
++  # The company name, if any
++
++# Check whether --with-company-name was given.
++if test ${with_company_name+y}
++then :
++  withval=$with_company_name;
++fi
++
++  if test "x$with_company_name" = xyes; then
++    as_fn_error $? "--with-company-name must have a value" "$LINENO" 5
++  elif  ! [[ $with_company_name =~ ^[[:print:]]*$ ]] ; then
++    as_fn_error $? "--with-company-name contains non-printing characters: $with_company_name" "$LINENO" 5
++  elif test "x$with_company_name" != x; then
++    COMPANY_NAME="$with_company_name"
++  fi
++
++
+   # The vendor name, if any
+ 
+ # Check whether --with-vendor-name was given.
+-if test "${with_vendor_name+set}" = set; then :
++if test ${with_vendor_name+y}
++then :
+   withval=$with_vendor_name;
+ fi
+ 
+@@ -20425,7 +22284,8 @@ fi
+   # The vendor URL, if any
+ 
+ # Check whether --with-vendor-url was given.
+-if test "${with_vendor_url+set}" = set; then :
++if test ${with_vendor_url+y}
++then :
+   withval=$with_vendor_url;
+ fi
+ 
+@@ -20441,7 +22301,8 @@ fi
+   # The vendor bug URL, if any
+ 
+ # Check whether --with-vendor-bug-url was given.
+-if test "${with_vendor_bug_url+set}" = set; then :
++if test ${with_vendor_bug_url+y}
++then :
+   withval=$with_vendor_bug_url;
+ fi
+ 
+@@ -20457,7 +22318,8 @@ fi
+   # The vendor VM bug URL, if any
+ 
+ # Check whether --with-vendor-vm-bug-url was given.
+-if test "${with_vendor_vm_bug_url+set}" = set; then :
++if test ${with_vendor_vm_bug_url+y}
++then :
+   withval=$with_vendor_vm_bug_url;
+ fi
+ 
+@@ -20472,7 +22334,8 @@ fi
+ 
+ 
+ # Check whether --with-copyright-year was given.
+-if test "${with_copyright_year+set}" = set; then :
++if test ${with_copyright_year+y}
++then :
+   withval=$with_copyright_year;
+ fi
+ 
+@@ -20512,7 +22375,8 @@ fi
+   BOOT_JDK_FOUND=no
+ 
+ # Check whether --with-boot-jdk was given.
+-if test "${with_boot_jdk+set}" = set; then :
++if test ${with_boot_jdk+y}
++then :
+   withval=$with_boot_jdk;
+ fi
+ 
+@@ -20530,8 +22394,8 @@ fi
+   if test "x$with_boot_jdk" != x; then
+     BOOT_JDK=$with_boot_jdk
+     BOOT_JDK_FOUND=maybe
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
+-$as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
++printf "%s\n" "$as_me: Found potential Boot JDK using configure arguments" >&6;}
+   fi
+ 
+ 
+@@ -20539,22 +22403,22 @@ $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -20563,10 +22427,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -20591,8 +22455,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -20640,8 +22504,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -20678,8 +22542,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -20690,8 +22554,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -20704,15 +22568,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -20752,8 +22616,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+       resource=${builddep_bootjdk}
+     fi
+     if test "x$resource" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for bootjdk" >&5
+-$as_echo "$as_me: Using builddeps $resource for bootjdk" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for bootjdk" >&5
++printf "%s\n" "$as_me: Using builddeps $resource for bootjdk" >&6;}
+       # If the resource in the builddeps.conf file is an existing directory,
+       # for example /java/linux/cups
+       if test -d ${resource}; then
+@@ -20773,8 +22637,8 @@ $as_echo "$as_me: Using builddeps $resource for bootjdk" >&6;}
+   extension=${filename#*.}
+   installdir=$with_builddeps_dir/$filebase
+   if test ! -f $installdir/$filename.unpacked; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&5
+-$as_echo "$as_me: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&5
++printf "%s\n" "$as_me: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&6;}
+     if test ! -d $installdir; then
+       mkdir -p $installdir
+     fi
+@@ -20882,22 +22746,22 @@ $as_echo "$as_me: Downloading build dependency bootjdk from $with_builddeps_serv
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -20906,10 +22770,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -20934,8 +22798,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -20983,8 +22847,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -21021,8 +22885,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -21033,8 +22897,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -21047,15 +22911,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -21091,8 +22955,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
+   fi
+ 
+@@ -21140,8 +23004,8 @@ $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\",
+ 
+   if test "x$path" != "x$new_path"; then
+     JAVA_HOME_PROCESSED="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -21178,8 +23042,8 @@ $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     JAVA_HOME_PROCESSED="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -21190,8 +23054,8 @@ $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
+     path="$JAVA_HOME_PROCESSED"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -21205,15 +23069,15 @@ $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\",
+   fi
+ 
+     if test ! -d "$JAVA_HOME_PROCESSED"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
+-$as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
++printf "%s\n" "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
+     else
+       # Aha, the user has set a JAVA_HOME
+       # let us use that as the Boot JDK.
+       BOOT_JDK="$JAVA_HOME_PROCESSED"
+       BOOT_JDK_FOUND=maybe
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
+-$as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
++printf "%s\n" "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
+     fi
+   fi
+ 
+@@ -21222,22 +23086,22 @@ $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -21246,10 +23110,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -21274,8 +23138,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -21323,8 +23187,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -21361,8 +23225,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -21373,8 +23237,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -21387,15 +23251,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -21412,8 +23276,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+   if test -x /usr/libexec/java_home; then
+     BOOT_JDK=`/usr/libexec/java_home`
+     BOOT_JDK_FOUND=maybe
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home" >&5
+-$as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home" >&5
++printf "%s\n" "$as_me: Found potential Boot JDK using /usr/libexec/java_home" >&6;}
+   fi
+ 
+ 
+@@ -21421,22 +23285,22 @@ $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home" >&6;}
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -21445,10 +23309,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -21473,8 +23337,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -21522,8 +23386,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -21560,8 +23424,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -21572,8 +23436,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -21586,15 +23450,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -21610,12 +23474,13 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+ 
+   # Extract the first word of "javac", so it can be a program name with args.
+ set dummy javac; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_JAVAC_CHECK+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $JAVAC_CHECK in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_JAVAC_CHECK+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $JAVAC_CHECK in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
+   ;;
+@@ -21624,11 +23489,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_JAVAC_CHECK="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -21636,26 +23505,28 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
+ if test -n "$JAVAC_CHECK"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
+-$as_echo "$JAVAC_CHECK" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
++printf "%s\n" "$JAVAC_CHECK" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+   # Extract the first word of "java", so it can be a program name with args.
+ set dummy java; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_JAVA_CHECK+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $JAVA_CHECK in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_JAVA_CHECK+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $JAVA_CHECK in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
+   ;;
+@@ -21664,11 +23535,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_JAVA_CHECK="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -21676,15 +23551,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ JAVA_CHECK=$ac_cv_path_JAVA_CHECK
+ if test -n "$JAVA_CHECK"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
+-$as_echo "$JAVA_CHECK" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
++printf "%s\n" "$JAVA_CHECK" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -21750,8 +23626,8 @@ fi
+     if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
+       # Looks like we found ourselves an JDK
+       BOOT_JDK_FOUND=maybe
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
+-$as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
++printf "%s\n" "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
+     fi
+   fi
+ 
+@@ -21760,22 +23636,22 @@ $as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -21784,10 +23660,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -21812,8 +23688,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -21861,8 +23737,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -21899,8 +23775,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -21911,8 +23787,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -21925,15 +23801,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -21977,8 +23853,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
+         if test -d "$BOOT_JDK"; then
+           BOOT_JDK_FOUND=maybe
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
+-$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
++printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
+         fi
+ 
+ 
+@@ -21986,22 +23862,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -22010,10 +23886,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -22038,8 +23914,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -22087,8 +23963,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -22125,8 +24001,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -22137,8 +24013,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -22151,15 +24027,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -22177,22 +24053,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -22201,10 +24077,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -22229,8 +24105,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -22278,8 +24154,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -22316,8 +24192,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -22328,8 +24204,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -22342,15 +24218,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -22387,8 +24263,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
+         if test -d "$BOOT_JDK"; then
+           BOOT_JDK_FOUND=maybe
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
+-$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
++printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
+         fi
+ 
+ 
+@@ -22396,22 +24272,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -22420,10 +24296,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -22448,8 +24324,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -22497,8 +24373,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -22535,8 +24411,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -22547,8 +24423,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -22561,15 +24437,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -22587,22 +24463,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -22611,10 +24487,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -22639,8 +24515,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -22688,8 +24564,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -22726,8 +24602,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -22738,8 +24614,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -22752,15 +24628,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -22797,8 +24673,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
+         if test -d "$BOOT_JDK"; then
+           BOOT_JDK_FOUND=maybe
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
+-$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
++printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
+         fi
+ 
+ 
+@@ -22806,22 +24682,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -22830,10 +24706,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -22858,8 +24734,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -22907,8 +24783,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -22945,8 +24821,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -22957,8 +24833,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -22971,15 +24847,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -22997,22 +24873,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -23021,10 +24897,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -23049,8 +24925,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -23098,8 +24974,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -23136,8 +25012,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -23148,8 +25024,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -23162,15 +25038,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -23207,8 +25083,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
+         if test -d "$BOOT_JDK"; then
+           BOOT_JDK_FOUND=maybe
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
+-$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
++printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
+         fi
+ 
+ 
+@@ -23216,22 +25092,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -23240,10 +25116,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -23268,8 +25144,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -23317,8 +25193,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -23355,8 +25231,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -23367,8 +25243,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -23381,15 +25257,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -23407,22 +25283,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -23431,10 +25307,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -23459,8 +25335,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -23508,8 +25384,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -23546,8 +25422,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -23558,8 +25434,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -23572,15 +25448,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -23604,8 +25480,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
+         if test -d "$BOOT_JDK"; then
+           BOOT_JDK_FOUND=maybe
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
+-$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
++printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
+         fi
+ 
+ 
+@@ -23613,22 +25489,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -23637,10 +25513,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -23665,8 +25541,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -23714,8 +25590,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -23752,8 +25628,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -23764,8 +25640,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -23778,15 +25654,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -23802,22 +25678,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -23826,10 +25702,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -23854,8 +25730,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -23903,8 +25779,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -23941,8 +25817,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -23953,8 +25829,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -23967,15 +25843,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -24000,8 +25876,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
+         if test -d "$BOOT_JDK"; then
+           BOOT_JDK_FOUND=maybe
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
+-$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
++printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
+         fi
+ 
+ 
+@@ -24009,22 +25885,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -24033,10 +25909,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -24061,8 +25937,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -24110,8 +25986,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -24148,8 +26024,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -24160,8 +26036,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -24174,15 +26050,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -24198,22 +26074,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -24222,10 +26098,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -24250,8 +26126,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -24299,8 +26175,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -24337,8 +26213,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -24349,8 +26225,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -24363,15 +26239,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -24395,8 +26271,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
+         if test -d "$BOOT_JDK"; then
+           BOOT_JDK_FOUND=maybe
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
+-$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
++printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
+         fi
+ 
+ 
+@@ -24404,22 +26280,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -24428,10 +26304,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -24456,8 +26332,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -24505,8 +26381,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -24543,8 +26419,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -24555,8 +26431,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -24569,15 +26445,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -24593,22 +26469,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -24617,10 +26493,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -24645,8 +26521,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -24694,8 +26570,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -24732,8 +26608,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -24744,8 +26620,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -24758,15 +26634,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -24791,8 +26667,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
+         if test -d "$BOOT_JDK"; then
+           BOOT_JDK_FOUND=maybe
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
+-$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
++printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
+         fi
+ 
+ 
+@@ -24800,22 +26676,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -24824,10 +26700,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -24852,8 +26728,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -24901,8 +26777,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -24939,8 +26815,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -24951,8 +26827,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -24965,15 +26841,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -24989,22 +26865,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -25013,10 +26889,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -25041,8 +26917,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -25090,8 +26966,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -25128,8 +27004,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -25140,8 +27016,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -25154,15 +27030,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -25177,22 +27053,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+     if test "x$BOOT_JDK_FOUND" = xmaybe; then
+       # Do we have a bin/java?
+       if test ! -x "$BOOT_JDK/bin/java"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
+         BOOT_JDK_FOUND=no
+       else
+         # Do we have a bin/javac?
+         if test ! -x "$BOOT_JDK/bin/javac"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
+-$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
++printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
+           BOOT_JDK_FOUND=no
+         else
+           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
+           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
+-            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
++            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
+             BOOT_JDK_FOUND=no
+           else
+             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
+@@ -25201,10 +27077,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
+             # Extra M4 quote needed to protect [] in grep expression.
+             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
+             if test "x$FOUND_VERSION_78" = x; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
+-$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
+-$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
++printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
++printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+               BOOT_JDK_FOUND=no
+             else
+               # We're done! :-)
+@@ -25229,8 +27105,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
+   fi
+ 
+@@ -25278,8 +27154,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -25316,8 +27192,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     BOOT_JDK="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -25328,8 +27204,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
+     path="$BOOT_JDK"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -25342,15 +27218,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
+     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
+-$as_echo_n "checking for Boot JDK... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
+-$as_echo "$BOOT_JDK" >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
+-$as_echo_n "checking Boot JDK version... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
++printf %s "checking for Boot JDK... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
++printf "%s\n" "$BOOT_JDK" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
++printf %s "checking Boot JDK version... " >&6; }
+               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
+-$as_echo "$BOOT_JDK_VERSION" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
++printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
+             fi # end check jdk version
+           fi # end check rt.jar
+         fi # end check javac
+@@ -25391,10 +27267,10 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
+     fi
+   fi
+ 
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find a valid Boot JDK. $HELP_MSG" >&5
+-$as_echo "$as_me: Could not find a valid Boot JDK. $HELP_MSG" >&6;}
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5
+-$as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find a valid Boot JDK. $HELP_MSG" >&5
++printf "%s\n" "$as_me: Could not find a valid Boot JDK. $HELP_MSG" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5
++printf "%s\n" "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;}
+     as_fn_error $? "Cannot continue" "$LINENO" 5
+   fi
+ 
+@@ -25416,102 +27292,102 @@ $as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&
+ 
+   # Setup tools from the Boot JDK.
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for java in Boot JDK" >&5
+-$as_echo_n "checking for java in Boot JDK... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for java in Boot JDK" >&5
++printf %s "checking for java in Boot JDK... " >&6; }
+   JAVA=$BOOT_JDK/bin/java
+   if test ! -x $JAVA; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
+-$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
++printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
+     as_fn_error $? "Could not find java in the Boot JDK" "$LINENO" 5
+   fi
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for javac in Boot JDK" >&5
+-$as_echo_n "checking for javac in Boot JDK... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for javac in Boot JDK" >&5
++printf %s "checking for javac in Boot JDK... " >&6; }
+   JAVAC=$BOOT_JDK/bin/javac
+   if test ! -x $JAVAC; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
+-$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
++printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
+     as_fn_error $? "Could not find javac in the Boot JDK" "$LINENO" 5
+   fi
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for javah in Boot JDK" >&5
+-$as_echo_n "checking for javah in Boot JDK... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for javah in Boot JDK" >&5
++printf %s "checking for javah in Boot JDK... " >&6; }
+   JAVAH=$BOOT_JDK/bin/javah
+   if test ! -x $JAVAH; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
+-$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
++printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
+     as_fn_error $? "Could not find javah in the Boot JDK" "$LINENO" 5
+   fi
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for javap in Boot JDK" >&5
+-$as_echo_n "checking for javap in Boot JDK... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for javap in Boot JDK" >&5
++printf %s "checking for javap in Boot JDK... " >&6; }
+   JAVAP=$BOOT_JDK/bin/javap
+   if test ! -x $JAVAP; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
+-$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
++printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
+     as_fn_error $? "Could not find javap in the Boot JDK" "$LINENO" 5
+   fi
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jar in Boot JDK" >&5
+-$as_echo_n "checking for jar in Boot JDK... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for jar in Boot JDK" >&5
++printf %s "checking for jar in Boot JDK... " >&6; }
+   JAR=$BOOT_JDK/bin/jar
+   if test ! -x $JAR; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
+-$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
++printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
+     as_fn_error $? "Could not find jar in the Boot JDK" "$LINENO" 5
+   fi
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for rmic in Boot JDK" >&5
+-$as_echo_n "checking for rmic in Boot JDK... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for rmic in Boot JDK" >&5
++printf %s "checking for rmic in Boot JDK... " >&6; }
+   RMIC=$BOOT_JDK/bin/rmic
+   if test ! -x $RMIC; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
+-$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
++printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
+     as_fn_error $? "Could not find rmic in the Boot JDK" "$LINENO" 5
+   fi
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for native2ascii in Boot JDK" >&5
+-$as_echo_n "checking for native2ascii in Boot JDK... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for native2ascii in Boot JDK" >&5
++printf %s "checking for native2ascii in Boot JDK... " >&6; }
+   NATIVE2ASCII=$BOOT_JDK/bin/native2ascii
+   if test ! -x $NATIVE2ASCII; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
+-$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
++printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
+     as_fn_error $? "Could not find native2ascii in the Boot JDK" "$LINENO" 5
+   fi
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+ 
+ 
+   # Finally, set some other options...
+@@ -25527,10 +27403,10 @@ $as_echo "ok" >&6; }
+   else
+     BOOT_JDK_BITS="32"
+   fi
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if Boot JDK is 32 or 64 bits" >&5
+-$as_echo_n "checking if Boot JDK is 32 or 64 bits... " >&6; }
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_BITS" >&5
+-$as_echo "$BOOT_JDK_BITS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if Boot JDK is 32 or 64 bits" >&5
++printf %s "checking if Boot JDK is 32 or 64 bits... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_BITS" >&5
++printf "%s\n" "$BOOT_JDK_BITS" >&6; }
+ 
+ 
+ 
+@@ -25540,13 +27416,14 @@ $as_echo "$BOOT_JDK_BITS" >&6; }
+   #
+ 
+ # Check whether --with-boot-jdk-jvmargs was given.
+-if test "${with_boot_jdk_jvmargs+set}" = set; then :
++if test ${with_boot_jdk_jvmargs+y}
++then :
+   withval=$with_boot_jdk_jvmargs;
+ fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command " >&5
+-$as_echo_n "checking flags for boot jdk java command ... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command " >&5
++printf %s "checking flags for boot jdk java command ... " >&6; }
+ 
+   # Disable special log output when a debug build is used as Boot JDK...
+ 
+@@ -25582,16 +27459,16 @@ $as_echo_n "checking flags for boot jdk java command ... " >&6; }
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs" >&5
+-$as_echo "$boot_jdk_jvmargs" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs" >&5
++printf "%s\n" "$boot_jdk_jvmargs" >&6; }
+ 
+   # For now, general JAVA_FLAGS are the same as the boot jdk jvmargs
+   JAVA_FLAGS=$boot_jdk_jvmargs
+ 
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for big workloads" >&5
+-$as_echo_n "checking flags for boot jdk java command for big workloads... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for big workloads" >&5
++printf %s "checking flags for boot jdk java command for big workloads... " >&6; }
+ 
+   # Starting amount of heap memory.
+ 
+@@ -25684,15 +27561,15 @@ $as_echo_n "checking flags for boot jdk java command for big workloads... " >&6;
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_big" >&5
+-$as_echo "$boot_jdk_jvmargs_big" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_big" >&5
++printf "%s\n" "$boot_jdk_jvmargs_big" >&6; }
+ 
+   JAVA_FLAGS_BIG=$boot_jdk_jvmargs_big
+ 
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for small workloads" >&5
+-$as_echo_n "checking flags for boot jdk java command for small workloads... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for small workloads" >&5
++printf %s "checking flags for boot jdk java command for small workloads... " >&6; }
+ 
+   # Use serial gc for small short lived tools if possible
+ 
+@@ -25741,8 +27618,8 @@ $as_echo_n "checking flags for boot jdk java command for small workloads... " >&
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_small" >&5
+-$as_echo "$boot_jdk_jvmargs_small" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_small" >&5
++printf "%s\n" "$boot_jdk_jvmargs_small" >&6; }
+ 
+   JAVA_FLAGS_SMALL=$boot_jdk_jvmargs_small
+ 
+@@ -25781,21 +27658,24 @@ $as_echo "$boot_jdk_jvmargs_small" >&6; }
+   #
+ 
+ # Check whether --with-add-source-root was given.
+-if test "${with_add_source_root+set}" = set; then :
++if test ${with_add_source_root+y}
++then :
+   withval=$with_add_source_root;
+ fi
+ 
+ 
+ 
+ # Check whether --with-override-source-root was given.
+-if test "${with_override_source_root+set}" = set; then :
++if test ${with_override_source_root+y}
++then :
+   withval=$with_override_source_root;
+ fi
+ 
+ 
+ 
+ # Check whether --with-adds-and-overrides was given.
+-if test "${with_adds_and_overrides+set}" = set; then :
++if test ${with_adds_and_overrides+y}
++then :
+   withval=$with_adds_and_overrides;
+ fi
+ 
+@@ -25892,49 +27772,56 @@ fi
+ 
+ 
+ # Check whether --with-override-langtools was given.
+-if test "${with_override_langtools+set}" = set; then :
++if test ${with_override_langtools+y}
++then :
+   withval=$with_override_langtools;
+ fi
+ 
+ 
+ 
+ # Check whether --with-override-corba was given.
+-if test "${with_override_corba+set}" = set; then :
++if test ${with_override_corba+y}
++then :
+   withval=$with_override_corba;
+ fi
+ 
+ 
+ 
+ # Check whether --with-override-jaxp was given.
+-if test "${with_override_jaxp+set}" = set; then :
++if test ${with_override_jaxp+y}
++then :
+   withval=$with_override_jaxp;
+ fi
+ 
+ 
+ 
+ # Check whether --with-override-jaxws was given.
+-if test "${with_override_jaxws+set}" = set; then :
++if test ${with_override_jaxws+y}
++then :
+   withval=$with_override_jaxws;
+ fi
+ 
+ 
+ 
+ # Check whether --with-override-hotspot was given.
+-if test "${with_override_hotspot+set}" = set; then :
++if test ${with_override_hotspot+y}
++then :
+   withval=$with_override_hotspot;
+ fi
+ 
+ 
+ 
+ # Check whether --with-override-nashorn was given.
+-if test "${with_override_nashorn+set}" = set; then :
++if test ${with_override_nashorn+y}
++then :
+   withval=$with_override_nashorn;
+ fi
+ 
+ 
+ 
+ # Check whether --with-override-jdk was given.
+-if test "${with_override_jdk+set}" = set; then :
++if test ${with_override_jdk+y}
++then :
+   withval=$with_override_jdk;
+ fi
+ 
+@@ -25947,10 +27834,10 @@ fi
+     if ! test -f $LANGTOOLS_TOPDIR/make/Makefile; then
+       as_fn_error $? "You have to override langtools with a full langtools repo!" "$LINENO" 5
+     fi
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if langtools should be overridden" >&5
+-$as_echo_n "checking if langtools should be overridden... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $LANGTOOLS_TOPDIR" >&5
+-$as_echo "yes with $LANGTOOLS_TOPDIR" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if langtools should be overridden" >&5
++printf %s "checking if langtools should be overridden... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $LANGTOOLS_TOPDIR" >&5
++printf "%s\n" "yes with $LANGTOOLS_TOPDIR" >&6; }
+   fi
+   if test "x$with_override_corba" != x; then
+     CURDIR="$PWD"
+@@ -25960,10 +27847,10 @@ $as_echo "yes with $LANGTOOLS_TOPDIR" >&6; }
+     if ! test -f $CORBA_TOPDIR/make/Makefile; then
+       as_fn_error $? "You have to override corba with a full corba repo!" "$LINENO" 5
+     fi
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if corba should be overridden" >&5
+-$as_echo_n "checking if corba should be overridden... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $CORBA_TOPDIR" >&5
+-$as_echo "yes with $CORBA_TOPDIR" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if corba should be overridden" >&5
++printf %s "checking if corba should be overridden... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $CORBA_TOPDIR" >&5
++printf "%s\n" "yes with $CORBA_TOPDIR" >&6; }
+   fi
+   if test "x$with_override_jaxp" != x; then
+     CURDIR="$PWD"
+@@ -25973,10 +27860,10 @@ $as_echo "yes with $CORBA_TOPDIR" >&6; }
+     if ! test -f $JAXP_TOPDIR/make/Makefile; then
+       as_fn_error $? "You have to override jaxp with a full jaxp repo!" "$LINENO" 5
+     fi
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if jaxp should be overridden" >&5
+-$as_echo_n "checking if jaxp should be overridden... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $JAXP_TOPDIR" >&5
+-$as_echo "yes with $JAXP_TOPDIR" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if jaxp should be overridden" >&5
++printf %s "checking if jaxp should be overridden... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $JAXP_TOPDIR" >&5
++printf "%s\n" "yes with $JAXP_TOPDIR" >&6; }
+   fi
+   if test "x$with_override_jaxws" != x; then
+     CURDIR="$PWD"
+@@ -25986,10 +27873,10 @@ $as_echo "yes with $JAXP_TOPDIR" >&6; }
+     if ! test -f $JAXWS_TOPDIR/make/Makefile; then
+       as_fn_error $? "You have to override jaxws with a full jaxws repo!" "$LINENO" 5
+     fi
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if jaxws should be overridden" >&5
+-$as_echo_n "checking if jaxws should be overridden... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $JAXWS_TOPDIR" >&5
+-$as_echo "yes with $JAXWS_TOPDIR" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if jaxws should be overridden" >&5
++printf %s "checking if jaxws should be overridden... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $JAXWS_TOPDIR" >&5
++printf "%s\n" "yes with $JAXWS_TOPDIR" >&6; }
+   fi
+   if test "x$with_override_hotspot" != x; then
+     CURDIR="$PWD"
+@@ -25999,10 +27886,10 @@ $as_echo "yes with $JAXWS_TOPDIR" >&6; }
+     if ! test -f $HOTSPOT_TOPDIR/make/Makefile; then
+       as_fn_error $? "You have to override hotspot with a full hotspot repo!" "$LINENO" 5
+     fi
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if hotspot should be overridden" >&5
+-$as_echo_n "checking if hotspot should be overridden... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $HOTSPOT_TOPDIR" >&5
+-$as_echo "yes with $HOTSPOT_TOPDIR" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if hotspot should be overridden" >&5
++printf %s "checking if hotspot should be overridden... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $HOTSPOT_TOPDIR" >&5
++printf "%s\n" "yes with $HOTSPOT_TOPDIR" >&6; }
+   fi
+   if test "x$with_override_nashorn" != x; then
+     CURDIR="$PWD"
+@@ -26012,10 +27899,10 @@ $as_echo "yes with $HOTSPOT_TOPDIR" >&6; }
+     if ! test -f $NASHORN_TOPDIR/make/Makefile; then
+       as_fn_error $? "You have to override nashorn with a full nashorn repo!" "$LINENO" 5
+     fi
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if nashorn should be overridden" >&5
+-$as_echo_n "checking if nashorn should be overridden... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $NASHORN_TOPDIR" >&5
+-$as_echo "yes with $NASHORN_TOPDIR" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if nashorn should be overridden" >&5
++printf %s "checking if nashorn should be overridden... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $NASHORN_TOPDIR" >&5
++printf "%s\n" "yes with $NASHORN_TOPDIR" >&6; }
+   fi
+   if test "x$with_override_jdk" != x; then
+     CURDIR="$PWD"
+@@ -26025,10 +27912,10 @@ $as_echo "yes with $NASHORN_TOPDIR" >&6; }
+     if ! test -f $JDK_TOPDIR/make/Makefile; then
+       as_fn_error $? "You have to override JDK with a full JDK repo!" "$LINENO" 5
+     fi
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if JDK should be overridden" >&5
+-$as_echo_n "checking if JDK should be overridden... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $JDK_TOPDIR" >&5
+-$as_echo "yes with $JDK_TOPDIR" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if JDK should be overridden" >&5
++printf %s "checking if JDK should be overridden... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $JDK_TOPDIR" >&5
++printf "%s\n" "yes with $JDK_TOPDIR" >&6; }
+   fi
+ 
+ 
+@@ -26041,7 +27928,8 @@ $as_echo "yes with $JDK_TOPDIR" >&6; }
+ 
+ 
+ # Check whether --with-import-hotspot was given.
+-if test "${with_import_hotspot+set}" = set; then :
++if test ${with_import_hotspot+y}
++then :
+   withval=$with_import_hotspot;
+ fi
+ 
+@@ -26053,10 +27941,10 @@ fi
+     if ! (test -d $HOTSPOT_DIST/lib && test -d $HOTSPOT_DIST/jre/lib); then
+       as_fn_error $? "You have to import hotspot from a full jdk image or hotspot build dist dir!" "$LINENO" 5
+     fi
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if hotspot should be imported" >&5
+-$as_echo_n "checking if hotspot should be imported... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes from $HOTSPOT_DIST" >&5
+-$as_echo "yes from $HOTSPOT_DIST" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if hotspot should be imported" >&5
++printf %s "checking if hotspot should be imported... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes from $HOTSPOT_DIST" >&5
++printf "%s\n" "yes from $HOTSPOT_DIST" >&6; }
+     BUILD_HOTSPOT=false
+   fi
+ 
+@@ -26074,7 +27962,8 @@ $as_echo "yes from $HOTSPOT_DIST" >&6; }
+ 
+ 
+ # Check whether --with-toolchain-type was given.
+-if test "${with_toolchain_type+set}" = set; then :
++if test ${with_toolchain_type+y}
++then :
+   withval=$with_toolchain_type;
+ fi
+ 
+@@ -26093,8 +27982,8 @@ fi
+     XCODE_MAJOR_VERSION=`$ECHO $XCODE_VERSION_OUTPUT | \
+         $SED -e 's/^Xcode \([1-9][0-9.]*\)/\1/' | \
+         $CUT -f 1 -d .`
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Xcode major version: $XCODE_MAJOR_VERSION" >&5
+-$as_echo "$as_me: Xcode major version: $XCODE_MAJOR_VERSION" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Xcode major version: $XCODE_MAJOR_VERSION" >&5
++printf "%s\n" "$as_me: Xcode major version: $XCODE_MAJOR_VERSION" >&6;}
+     if test $XCODE_MAJOR_VERSION -ge 5; then
+         DEFAULT_TOOLCHAIN="clang"
+     else
+@@ -26107,8 +27996,8 @@ $as_echo "$as_me: Xcode major version: $XCODE_MAJOR_VERSION" >&6;}
+ 
+   if test "x$with_toolchain_type" = xlist; then
+     # List all toolchains
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The following toolchains are valid on this platform:" >&5
+-$as_echo "$as_me: The following toolchains are valid on this platform:" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The following toolchains are valid on this platform:" >&5
++printf "%s\n" "$as_me: The following toolchains are valid on this platform:" >&6;}
+     for toolchain in $VALID_TOOLCHAINS; do
+       toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
+       TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
+@@ -26119,10 +28008,10 @@ $as_echo "$as_me: The following toolchains are valid on this platform:" >&6;}
+   elif test "x$with_toolchain_type" != x; then
+     # User override; check that it is valid
+     if test "x${VALID_TOOLCHAINS/$with_toolchain_type/}" = "x${VALID_TOOLCHAINS}"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Toolchain type $with_toolchain_type is not valid on this platform." >&5
+-$as_echo "$as_me: Toolchain type $with_toolchain_type is not valid on this platform." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Valid toolchains: $VALID_TOOLCHAINS." >&5
+-$as_echo "$as_me: Valid toolchains: $VALID_TOOLCHAINS." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Toolchain type $with_toolchain_type is not valid on this platform." >&5
++printf "%s\n" "$as_me: Toolchain type $with_toolchain_type is not valid on this platform." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Valid toolchains: $VALID_TOOLCHAINS." >&5
++printf "%s\n" "$as_me: Valid toolchains: $VALID_TOOLCHAINS." >&6;}
+       as_fn_error $? "Cannot continue." "$LINENO" 5
+     fi
+     TOOLCHAIN_TYPE=$with_toolchain_type
+@@ -26186,11 +28075,11 @@ $as_echo "$as_me: Valid toolchains: $VALID_TOOLCHAINS." >&6;}
+ 
+ 
+   if test "x$TOOLCHAIN_TYPE" = "x$DEFAULT_TOOLCHAIN"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)" >&5
+-$as_echo "$as_me: Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)" >&5
++printf "%s\n" "$as_me: Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)" >&6;}
+   else
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&5
+-$as_echo "$as_me: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&5
++printf "%s\n" "$as_me: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&6;}
+   fi
+ 
+ 
+@@ -26223,12 +28112,13 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+   # VS linker. This must be done before changing the PATH when looking for VS.
+   # Extract the first word of "link", so it can be a program name with args.
+ set dummy link; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CYGWIN_LINK+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CYGWIN_LINK in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CYGWIN_LINK+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CYGWIN_LINK in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CYGWIN_LINK="$CYGWIN_LINK" # Let the user override the test with a path.
+   ;;
+@@ -26237,11 +28127,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CYGWIN_LINK="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CYGWIN_LINK="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -26249,28 +28143,29 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CYGWIN_LINK=$ac_cv_path_CYGWIN_LINK
+ if test -n "$CYGWIN_LINK"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_LINK" >&5
+-$as_echo "$CYGWIN_LINK" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_LINK" >&5
++printf "%s\n" "$CYGWIN_LINK" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+   if test "x$CYGWIN_LINK" != x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the first found link.exe is actually the Cygwin link tool" >&5
+-$as_echo_n "checking if the first found link.exe is actually the Cygwin link tool... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the first found link.exe is actually the Cygwin link tool" >&5
++printf %s "checking if the first found link.exe is actually the Cygwin link tool... " >&6; }
+     "$CYGWIN_LINK" --version > /dev/null
+     if test $? -eq 0 ; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+       # This might be the VS linker. Don't exclude it later on.
+       CYGWIN_LINK=""
+     fi
+@@ -26280,15 +28175,16 @@ $as_echo "no" >&6; }
+ 
+ 
+ # Check whether --with-toolchain-version was given.
+-if test "${with_toolchain_version+set}" = set; then :
++if test ${with_toolchain_version+y}
++then :
+   withval=$with_toolchain_version;
+ fi
+ 
+ 
+   if test "x$with_toolchain_version" = xlist; then
+     # List all toolchains
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The following toolchain versions are valid on this platform:" >&5
+-$as_echo "$as_me: The following toolchain versions are valid on this platform:" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The following toolchain versions are valid on this platform:" >&5
++printf "%s\n" "$as_me: The following toolchain versions are valid on this platform:" >&6;}
+     for version in $VALID_VS_VERSIONS; do
+       eval VS_DESCRIPTION=\${VS_DESCRIPTION_$version}
+       $PRINTF "  %-10s  %s\n" $version "$VS_DESCRIPTION"
+@@ -26348,16 +28244,16 @@ $as_echo "$as_me: The following toolchain versions are valid on this platform:"
+     done
+     IFS="$OLDIFS"
+ 
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found devkit $VS_DESCRIPTION" >&5
+-$as_echo "$as_me: Found devkit $VS_DESCRIPTION" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found devkit $VS_DESCRIPTION" >&5
++printf "%s\n" "$as_me: Found devkit $VS_DESCRIPTION" >&6;}
+ 
+   elif test "x$with_toolchain_version" != x; then
+     # User override; check that it is valid
+     if test "x${VALID_VS_VERSIONS/$with_toolchain_version/}" = "x${VALID_VS_VERSIONS}"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Visual Studio version $with_toolchain_version is not valid." >&5
+-$as_echo "$as_me: Visual Studio version $with_toolchain_version is not valid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&5
+-$as_echo "$as_me: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Visual Studio version $with_toolchain_version is not valid." >&5
++printf "%s\n" "$as_me: Visual Studio version $with_toolchain_version is not valid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&5
++printf "%s\n" "$as_me: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&6;}
+       as_fn_error $? "Cannot continue." "$LINENO" 5
+     fi
+     VS_VERSIONS_PROBE_LIST="$with_toolchain_version"
+@@ -26407,8 +28303,8 @@ $as_echo "$as_me: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&6;}
+     fi
+ 
+     if test -d "$VS_BASE"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
+       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
+       else
+@@ -26424,8 +28320,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
+       done
+ 
+       if test "x$VS_ENV_CMD" = x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
+-$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
+       else
+         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
+         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
+@@ -26464,8 +28360,8 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
+     fi
+ 
+     if test -d "$VS_BASE"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
+       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
+       else
+@@ -26481,8 +28377,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
+       done
+ 
+       if test "x$VS_ENV_CMD" = x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
+-$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
+       else
+         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
+         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
+@@ -26496,12 +28392,12 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
+     if test "x$VS_ENV_CMD" = x; then
+       # Having specified an argument which is incorrect will produce an instant failure;
+       # we should not go on looking
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path given by --with-tools-dir does not contain a valid" >&5
+-$as_echo "$as_me: The path given by --with-tools-dir does not contain a valid" >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&5
+-$as_echo "$as_me: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: directory within the Visual Studio installation" >&5
+-$as_echo "$as_me: directory within the Visual Studio installation" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path given by --with-tools-dir does not contain a valid" >&5
++printf "%s\n" "$as_me: The path given by --with-tools-dir does not contain a valid" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&5
++printf "%s\n" "$as_me: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: directory within the Visual Studio installation" >&5
++printf "%s\n" "$as_me: directory within the Visual Studio installation" >&6;}
+       as_fn_error $? "Cannot locate a valid Visual Studio installation" "$LINENO" 5
+     fi
+   fi
+@@ -26537,8 +28433,8 @@ $as_echo "$as_me: directory within the Visual Studio installation" >&6;}
+     fi
+ 
+     if test -d "$VS_BASE"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
+       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
+       else
+@@ -26554,8 +28450,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
+       done
+ 
+       if test "x$VS_ENV_CMD" = x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
+-$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
+       else
+         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
+         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
+@@ -26596,8 +28492,8 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
+     fi
+ 
+     if test -d "$VS_BASE"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
+       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
+       else
+@@ -26613,8 +28509,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
+       done
+ 
+       if test "x$VS_ENV_CMD" = x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
+-$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
+       else
+         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
+         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
+@@ -26657,8 +28553,8 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
+     fi
+ 
+     if test -d "$VS_BASE"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
+       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
+       else
+@@ -26674,8 +28570,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
+       done
+ 
+       if test "x$VS_ENV_CMD" = x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
+-$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
+       else
+         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
+         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
+@@ -26715,8 +28611,8 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
+     fi
+ 
+     if test -d "$VS_BASE"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
+       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
+       else
+@@ -26732,8 +28628,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
+       done
+ 
+       if test "x$VS_ENV_CMD" = x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
+-$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
+       else
+         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
+         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
+@@ -26772,8 +28668,8 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
+     fi
+ 
+     if test -d "$VS_BASE"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
+       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
+       else
+@@ -26789,8 +28685,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
+       done
+ 
+       if test "x$VS_ENV_CMD" = x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
+-$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
+       else
+         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
+         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
+@@ -26823,13 +28719,13 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
+       # There have been cases of partial or broken SDK installations. A missing
+       # lib dir is not going to work.
+       if test ! -d "$WIN_SDK_BASE/lib"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
+-$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
+       elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+         VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
+         if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+           VS_ENV_ARGS="/x86"
+@@ -26841,10 +28737,10 @@ $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD"
+         # TODO: improve detection for other versions of SDK
+         eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
+       else
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
+-$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
+       fi
+     fi
+   fi
+@@ -26870,13 +28766,13 @@ $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignori
+       # There have been cases of partial or broken SDK installations. A missing
+       # lib dir is not going to work.
+       if test ! -d "$WIN_SDK_BASE/lib"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
+-$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
+       elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+         VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
+         if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+           VS_ENV_ARGS="/x86"
+@@ -26888,10 +28784,10 @@ $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD"
+         # TODO: improve detection for other versions of SDK
+         eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
+       else
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
+-$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
+       fi
+     fi
+   fi
+@@ -26917,13 +28813,13 @@ $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignori
+       # There have been cases of partial or broken SDK installations. A missing
+       # lib dir is not going to work.
+       if test ! -d "$WIN_SDK_BASE/lib"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
+-$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
+       elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+         VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
+         if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+           VS_ENV_ARGS="/x86"
+@@ -26935,10 +28831,10 @@ $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD"
+         # TODO: improve detection for other versions of SDK
+         eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
+       else
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
+-$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
+       fi
+     fi
+   fi
+@@ -26963,13 +28859,13 @@ $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignori
+       # There have been cases of partial or broken SDK installations. A missing
+       # lib dir is not going to work.
+       if test ! -d "$WIN_SDK_BASE/lib"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
+-$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
+       elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+         VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
+         if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+           VS_ENV_ARGS="/x86"
+@@ -26981,10 +28877,10 @@ $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD"
+         # TODO: improve detection for other versions of SDK
+         eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
+       else
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
+-$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
+       fi
+     fi
+   fi
+@@ -27008,13 +28904,13 @@ $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignori
+       # There have been cases of partial or broken SDK installations. A missing
+       # lib dir is not going to work.
+       if test ! -d "$WIN_SDK_BASE/lib"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
+-$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
+       elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+         VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
+         if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
+           VS_ENV_ARGS="/x86"
+@@ -27026,10 +28922,10 @@ $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD"
+         # TODO: improve detection for other versions of SDK
+         eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
+       else
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
+-$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
+-$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
++printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
++printf "%s\n" "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
+       fi
+     fi
+   fi
+@@ -27045,8 +28941,8 @@ $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignori
+       eval MSVCP_NAME="\${VS_MSVCP_${VS_VERSION}}"
+       eval USE_UCRT="\${VS_USE_UCRT_${VS_VERSION}}"
+       # The rest of the variables are already evaled while probing
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found $VS_DESCRIPTION" >&5
+-$as_echo "$as_me: Found $VS_DESCRIPTION" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $VS_DESCRIPTION" >&5
++printf "%s\n" "$as_me: Found $VS_DESCRIPTION" >&6;}
+       break
+     fi
+   done
+@@ -27102,12 +28998,12 @@ $as_echo "$as_me: Found $VS_DESCRIPTION" >&6;}
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
+     fi
+@@ -27129,10 +29025,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of VS_ENV_CMD, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
+     fi
+   else
+@@ -27242,12 +29138,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
+     fi
+@@ -27319,12 +29215,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
+     fi
+@@ -27339,14 +29235,14 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     VS_ENV_CMD="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting VS_ENV_CMD to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting VS_ENV_CMD to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting VS_ENV_CMD to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting VS_ENV_CMD to \"$new_complete\"" >&6;}
+   fi
+ 
+ 
+       # Lets extract the variables that are set by vcvarsall.bat/vsvars32.bat/vsvars64.bat
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Trying to extract Visual Studio environment variables" >&5
+-$as_echo "$as_me: Trying to extract Visual Studio environment variables" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Trying to extract Visual Studio environment variables" >&5
++printf "%s\n" "$as_me: Trying to extract Visual Studio environment variables" >&6;}
+ 
+       # We need to create a couple of temporary files.
+       VS_ENV_TMP_DIR="$OUTPUT_ROOT/vs-env"
+@@ -27412,42 +29308,42 @@ $as_echo "$as_me: Trying to extract Visual Studio environment variables" >&6;}
+       cd $CURDIR
+ 
+       if test ! -s $VS_ENV_TMP_DIR/set-vs-env.sh; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Could not succesfully extract the envionment variables needed for the VS setup." >&5
+-$as_echo "$as_me: Could not succesfully extract the envionment variables needed for the VS setup." >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
+-$as_echo "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
+-$as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not succesfully extract the envionment variables needed for the VS setup." >&5
++printf "%s\n" "$as_me: Could not succesfully extract the envionment variables needed for the VS setup." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
++printf "%s\n" "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
++printf "%s\n" "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
+         as_fn_error $? "Cannot continue" "$LINENO" 5
+       fi
+ 
+       # Now set all paths and other env variables. This will allow the rest of
+       # the configure script to find and run the compiler in the proper way.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Setting extracted environment variables" >&5
+-$as_echo "$as_me: Setting extracted environment variables" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Setting extracted environment variables" >&5
++printf "%s\n" "$as_me: Setting extracted environment variables" >&6;}
+       . $VS_ENV_TMP_DIR/set-vs-env.sh
+       # Now we have VS_PATH, VS_INCLUDE, VS_LIB. For further checking, we
+       # also define VCINSTALLDIR, WindowsSdkDir and WINDOWSSDKDIR.
+     else
+       # We did not find a vsvars bat file, let's hope we are run from a VS command prompt.
+-     { $as_echo "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio installation, checking current environment" >&5
+-$as_echo "$as_me: Cannot locate a valid Visual Studio installation, checking current environment" >&6;}
++     { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio installation, checking current environment" >&5
++printf "%s\n" "$as_me: Cannot locate a valid Visual Studio installation, checking current environment" >&6;}
+     fi
+   fi
+ 
+   # At this point, we should have correct variables in the environment, or we can't continue.
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Visual Studio variables" >&5
+-$as_echo_n "checking for Visual Studio variables... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Visual Studio variables" >&5
++printf %s "checking for Visual Studio variables... " >&6; }
+ 
+   if test "x$VCINSTALLDIR" != x || test "x$WindowsSDKDir" != x \
+       || test "x$WINDOWSSDKDIR" != x || test "x$DEVKIT_NAME" != x; then
+     if test "x$VS_INCLUDE" = x || test "x$VS_LIB" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: present but broken" >&5
+-$as_echo "present but broken" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: present but broken" >&5
++printf "%s\n" "present but broken" >&6; }
+       as_fn_error $? "Your VC command prompt seems broken, INCLUDE and/or LIB is missing." "$LINENO" 5
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       # Remove any trailing "\" and " " from the variables.
+       VS_INCLUDE=`$ECHO "$VS_INCLUDE" | $SED 's/\\\\* *$//'`
+       VS_LIB=`$ECHO "$VS_LIB" | $SED 's/\\\\* *$//'`
+@@ -27466,22 +29362,22 @@ $as_echo "ok" >&6; }
+ 
+     fi
+   else
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+ 
+     if test "x$VS_ENV_CMD" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio or Windows SDK installation on disk," >&5
+-$as_echo "$as_me: Cannot locate a valid Visual Studio or Windows SDK installation on disk," >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: nor is this script run from a Visual Studio command prompt." >&5
+-$as_echo "$as_me: nor is this script run from a Visual Studio command prompt." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio or Windows SDK installation on disk," >&5
++printf "%s\n" "$as_me: Cannot locate a valid Visual Studio or Windows SDK installation on disk," >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: nor is this script run from a Visual Studio command prompt." >&5
++printf "%s\n" "$as_me: nor is this script run from a Visual Studio command prompt." >&6;}
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Running the extraction script failed." >&5
+-$as_echo "$as_me: Running the extraction script failed." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Running the extraction script failed." >&5
++printf "%s\n" "$as_me: Running the extraction script failed." >&6;}
+     fi
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
+-$as_echo "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
+-$as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
++printf "%s\n" "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
++printf "%s\n" "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
+     as_fn_error $? "Cannot continue" "$LINENO" 5
+   fi
+ 
+@@ -27504,8 +29400,8 @@ $as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run c
+     fi
+ 
+     # DEVELOPER_DIR could also be provided directly
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking Determining if we need to set DEVELOPER_DIR" >&5
+-$as_echo_n "checking Determining if we need to set DEVELOPER_DIR... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Determining if we need to set DEVELOPER_DIR" >&5
++printf %s "checking Determining if we need to set DEVELOPER_DIR... " >&6; }
+     if test -n "$DEVELOPER_DIR"; then
+       if test ! -d "$DEVELOPER_DIR"; then
+         as_fn_error $? "Xcode Developer path does not exist: $DEVELOPER_DIR, please provide a path to the Xcode application bundle using --with-xcode-path" "$LINENO" 5
+@@ -27516,22 +29412,23 @@ $as_echo_n "checking Determining if we need to set DEVELOPER_DIR... " >&6; }
+       # make it visible to all the tools immediately
+       export DEVELOPER_DIR
+       SET_DEVELOPER_DIR="export DEVELOPER_DIR := $DEVELOPER_DIR"
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes ($DEVELOPER_DIR)" >&5
+-$as_echo "yes ($DEVELOPER_DIR)" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes ($DEVELOPER_DIR)" >&5
++printf "%s\n" "yes ($DEVELOPER_DIR)" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+     fi
+ 
+ 
+     # Extract the first word of "xcodebuild", so it can be a program name with args.
+ set dummy xcodebuild; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_XCODEBUILD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $XCODEBUILD in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_XCODEBUILD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $XCODEBUILD in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
+   ;;
+@@ -27540,11 +29437,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_XCODEBUILD="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -27552,15 +29453,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ XCODEBUILD=$ac_cv_path_XCODEBUILD
+ if test -n "$XCODEBUILD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
+-$as_echo "$XCODEBUILD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
++printf "%s\n" "$XCODEBUILD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -27573,23 +29475,23 @@ fi
+     if test -L "/usr/bin/gcc" -o -L "/usr/bin/g++"; then
+       # use xcrun to find the real gcc and add it's directory to PATH
+       # then autoconf magic will find it
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Found gcc symlinks to clang in /usr/bin, adding path to real gcc to PATH" >&5
+-$as_echo "$as_me: Found gcc symlinks to clang in /usr/bin, adding path to real gcc to PATH" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found gcc symlinks to clang in /usr/bin, adding path to real gcc to PATH" >&5
++printf "%s\n" "$as_me: Found gcc symlinks to clang in /usr/bin, adding path to real gcc to PATH" >&6;}
+       XCODE_BIN_PATH=$(dirname `xcrun -find gcc`)
+       PATH="$XCODE_BIN_PATH":$PATH
+     fi
+ 
+     # Determine appropriate SDKPATH, don't use SDKROOT as it interferes with the stub tools
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking Determining Xcode SDK path" >&5
+-$as_echo_n "checking Determining Xcode SDK path... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Determining Xcode SDK path" >&5
++printf %s "checking Determining Xcode SDK path... " >&6; }
+     # allow SDKNAME to be set to override the default SDK selection
+     SDKPATH=`"$XCODEBUILD" -sdk ${SDKNAME:-macosx} -version | grep '^Path: ' | sed 's/Path: //'`
+     if test -n "$SDKPATH"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKPATH" >&5
+-$as_echo "$SDKPATH" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SDKPATH" >&5
++printf "%s\n" "$SDKPATH" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: (none, will use system headers and frameworks)" >&5
+-$as_echo "(none, will use system headers and frameworks)" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: (none, will use system headers and frameworks)" >&5
++printf "%s\n" "(none, will use system headers and frameworks)" >&6; }
+     fi
+ 
+ 
+@@ -27630,6 +29532,21 @@ $as_echo "(none, will use system headers and frameworks)" >&6; }
+   fi
+ 
+ 
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++
+   #
+   # Setup the compilers (CC and CXX)
+   #
+@@ -27639,8 +29556,8 @@ $as_echo "(none, will use system headers and frameworks)" >&6; }
+ 
+   if test "x$CC" != x; then
+     # User has supplied compiler name already, always let that override.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied compiler CC=$CC" >&5
+-$as_echo "$as_me: Will use user supplied compiler CC=$CC" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied compiler CC=$CC" >&5
++printf "%s\n" "$as_me: Will use user supplied compiler CC=$CC" >&6;}
+     if test "x`basename $CC`" = "x$CC"; then
+       # A command without a complete path is provided, search $PATH.
+ 
+@@ -27648,12 +29565,13 @@ $as_echo "$as_me: Will use user supplied compiler CC=$CC" >&6;}
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_POTENTIAL_CC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $POTENTIAL_CC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_POTENTIAL_CC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $POTENTIAL_CC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_POTENTIAL_CC="$POTENTIAL_CC" # Let the user override the test with a path.
+   ;;
+@@ -27662,11 +29580,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_POTENTIAL_CC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_POTENTIAL_CC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -27674,15 +29596,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ POTENTIAL_CC=$ac_cv_path_POTENTIAL_CC
+ if test -n "$POTENTIAL_CC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CC" >&5
+-$as_echo "$POTENTIAL_CC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CC" >&5
++printf "%s\n" "$POTENTIAL_CC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -27722,12 +29645,13 @@ done
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TOOLCHAIN_PATH_CC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TOOLCHAIN_PATH_CC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TOOLCHAIN_PATH_CC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TOOLCHAIN_PATH_CC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TOOLCHAIN_PATH_CC="$TOOLCHAIN_PATH_CC" # Let the user override the test with a path.
+   ;;
+@@ -27736,11 +29660,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TOOLCHAIN_PATH_CC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TOOLCHAIN_PATH_CC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -27748,15 +29676,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TOOLCHAIN_PATH_CC=$ac_cv_path_TOOLCHAIN_PATH_CC
+ if test -n "$TOOLCHAIN_PATH_CC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH_CC" >&5
+-$as_echo "$TOOLCHAIN_PATH_CC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH_CC" >&5
++printf "%s\n" "$TOOLCHAIN_PATH_CC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -27774,12 +29703,13 @@ done
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_POTENTIAL_CC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $POTENTIAL_CC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_POTENTIAL_CC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $POTENTIAL_CC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_POTENTIAL_CC="$POTENTIAL_CC" # Let the user override the test with a path.
+   ;;
+@@ -27788,11 +29718,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_POTENTIAL_CC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_POTENTIAL_CC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -27800,15 +29734,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ POTENTIAL_CC=$ac_cv_path_POTENTIAL_CC
+ if test -n "$POTENTIAL_CC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CC" >&5
+-$as_echo "$POTENTIAL_CC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CC" >&5
++printf "%s\n" "$POTENTIAL_CC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -27895,12 +29830,12 @@ done
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
+     fi
+@@ -27922,10 +29857,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of CC, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CC, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
+     fi
+   else
+@@ -28035,12 +29970,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
+     fi
+@@ -28112,12 +30047,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
+     fi
+@@ -28132,14 +30067,14 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     CC="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CC to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting CC to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CC to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting CC to \"$new_complete\"" >&6;}
+   fi
+ 
+   TEST_COMPILER="$CC"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking resolved symbolic links for CC" >&5
+-$as_echo_n "checking resolved symbolic links for CC... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking resolved symbolic links for CC" >&5
++printf %s "checking resolved symbolic links for CC... " >&6; }
+   SYMLINK_ORIGINAL="$TEST_COMPILER"
+ 
+   if test "x$OPENJDK_BUILD_OS" != xwindows; then
+@@ -28190,17 +30125,17 @@ $as_echo_n "checking resolved symbolic links for CC... " >&6; }
+   fi
+ 
+   if test "x$TEST_COMPILER" = "x$SYMLINK_ORIGINAL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no symlink" >&5
+-$as_echo "no symlink" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no symlink" >&5
++printf "%s\n" "no symlink" >&6; }
+   else
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYMLINK_ORIGINAL" >&5
+-$as_echo "$SYMLINK_ORIGINAL" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if CC is disguised ccache" >&5
+-$as_echo_n "checking if CC is disguised ccache... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SYMLINK_ORIGINAL" >&5
++printf "%s\n" "$SYMLINK_ORIGINAL" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if CC is disguised ccache" >&5
++printf %s "checking if CC is disguised ccache... " >&6; }
+     COMPILER_BASENAME=`$BASENAME "$SYMLINK_ORIGINAL"`
+     if test "x$COMPILER_BASENAME" = "xccache"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, trying to find proper $COMPILER_NAME compiler" >&5
+-$as_echo "yes, trying to find proper $COMPILER_NAME compiler" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes, trying to find proper $COMPILER_NAME compiler" >&5
++printf "%s\n" "yes, trying to find proper $COMPILER_NAME compiler" >&6; }
+       # We /usr/lib/ccache in the path, so cc is a symlink to /usr/bin/ccache.
+       # We want to control ccache invocation ourselves, so ignore this cc and try
+       # searching again.
+@@ -28215,38 +30150,44 @@ $as_echo "yes, trying to find proper $COMPILER_NAME compiler" >&6; }
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_PROPER_COMPILER_CC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$PROPER_COMPILER_CC"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_PROPER_COMPILER_CC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$PROPER_COMPILER_CC"; then
+   ac_cv_prog_PROPER_COMPILER_CC="$PROPER_COMPILER_CC" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_PROPER_COMPILER_CC="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ PROPER_COMPILER_CC=$ac_cv_prog_PROPER_COMPILER_CC
+ if test -n "$PROPER_COMPILER_CC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CC" >&5
+-$as_echo "$PROPER_COMPILER_CC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CC" >&5
++printf "%s\n" "$PROPER_COMPILER_CC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -28259,38 +30200,44 @@ if test -z "$PROPER_COMPILER_CC"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_PROPER_COMPILER_CC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_PROPER_COMPILER_CC"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_PROPER_COMPILER_CC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_PROPER_COMPILER_CC"; then
+   ac_cv_prog_ac_ct_PROPER_COMPILER_CC="$ac_ct_PROPER_COMPILER_CC" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_PROPER_COMPILER_CC="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_PROPER_COMPILER_CC=$ac_cv_prog_ac_ct_PROPER_COMPILER_CC
+ if test -n "$ac_ct_PROPER_COMPILER_CC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_PROPER_COMPILER_CC" >&5
+-$as_echo "$ac_ct_PROPER_COMPILER_CC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_PROPER_COMPILER_CC" >&5
++printf "%s\n" "$ac_ct_PROPER_COMPILER_CC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -28302,8 +30249,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     PROPER_COMPILER_CC=$ac_ct_PROPER_COMPILER_CC
+@@ -28351,12 +30298,12 @@ fi
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CC" "$LINENO" 5
+     fi
+@@ -28378,10 +30325,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CC" "$LINENO" 5
+     fi
+   else
+@@ -28491,12 +30438,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CC" "$LINENO" 5
+     fi
+@@ -28568,12 +30515,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CC" "$LINENO" 5
+     fi
+@@ -28588,14 +30535,14 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     PROPER_COMPILER_CC="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting PROPER_COMPILER_CC to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting PROPER_COMPILER_CC to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting PROPER_COMPILER_CC to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting PROPER_COMPILER_CC to \"$new_complete\"" >&6;}
+   fi
+ 
+       PATH="$RETRY_COMPILER_SAVED_PATH"
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for resolved symbolic links for CC" >&5
+-$as_echo_n "checking for resolved symbolic links for CC... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for resolved symbolic links for CC" >&5
++printf %s "checking for resolved symbolic links for CC... " >&6; }
+ 
+   if test "x$OPENJDK_BUILD_OS" != xwindows; then
+     # Follow a chain of symbolic links. Use readlink
+@@ -28644,12 +30591,12 @@ $as_echo_n "checking for resolved symbolic links for CC... " >&6; }
+     fi
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CC" >&5
+-$as_echo "$PROPER_COMPILER_CC" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CC" >&5
++printf "%s\n" "$PROPER_COMPILER_CC" >&6; }
+       CC="$PROPER_COMPILER_CC"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, keeping CC" >&5
+-$as_echo "no, keeping CC" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, keeping CC" >&5
++printf "%s\n" "no, keeping CC" >&6; }
+     fi
+   fi
+ 
+@@ -28665,12 +30612,12 @@ $as_echo "no, keeping CC" >&6; }
+     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null
+     if test $? -ne 0; then
+       ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
+-$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
+-$as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
+-$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
++printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
++printf "%s\n" "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
++printf "%s\n" "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
+       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
+     fi
+     # Remove usage instructions (if present), and
+@@ -28688,12 +30635,12 @@ $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUT
+     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
+     if test $? -ne 0; then
+       ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
+-$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
+-$as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
+-$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
++printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
++printf "%s\n" "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
++printf "%s\n" "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
+       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
+     fi
+     # Collapse compiler output into a single line
+@@ -28708,10 +30655,10 @@ $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUT
+     # Check that this is likely to be Microsoft CL.EXE.
+     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
+     if test $? -ne 0; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
+-$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
+-$as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
++printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
++printf "%s\n" "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
+       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
+     fi
+     # Collapse compiler output into a single line
+@@ -28728,10 +30675,10 @@ $as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\""
+     # Check that this is likely to be GCC.
+     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
+     if test $? -ne 0; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
+-$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
+-$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
++printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
++printf "%s\n" "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
+       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
+     fi
+     # Remove Copyright and legalese from version string, and
+@@ -28752,10 +30699,10 @@ $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSIO
+     # Check that this is likely to be clang
+     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
+     if test $? -ne 0; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
+-$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
+-$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
++printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
++printf "%s\n" "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
+       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
+     fi
+     # Collapse compiler output into a single line
+@@ -28771,8 +30718,8 @@ $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSIO
+   # This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
+   CC_VERSION_STRING="$COMPILER_VERSION_STRING"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
+-$as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
++printf "%s\n" "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
+ 
+ 
+   # Now that we have resolved CC ourself, let autoconf have its go at it
+@@ -28786,38 +30733,44 @@ if test -n "$ac_tool_prefix"; then
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_CC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$CC"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_CC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$CC"; then
+   ac_cv_prog_CC="$CC" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ CC=$ac_cv_prog_CC
+ if test -n "$CC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+-$as_echo "$CC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
++printf "%s\n" "$CC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -28830,38 +30783,44 @@ if test -z "$CC"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_CC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_CC"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_CC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_CC"; then
+   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_CC="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_CC=$ac_cv_prog_ac_ct_CC
+ if test -n "$ac_ct_CC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+-$as_echo "$ac_ct_CC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
++printf "%s\n" "$ac_ct_CC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -28873,8 +30832,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     CC=$ac_ct_CC
+@@ -28882,23 +30841,23 @@ esac
+ fi
+ 
+ 
+-test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
++test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
++printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ as_fn_error $? "no acceptable C compiler found in \$PATH
+-See \`config.log' for more details" "$LINENO" 5; }
++See 'config.log' for more details" "$LINENO" 5; }
+ 
+ # Provide some information about the compiler.
+-$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
++printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+ set X $ac_compile
+ ac_compiler=$2
+-for ac_option in --version -v -V -qversion; do
++for ac_option in --version -v -V -qversion -version; do
+   { { ac_try="$ac_compiler $ac_option >&5"
+ case "(($ac_try" in
+   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+   ac_status=$?
+   if test -s conftest.err; then
+@@ -28908,7 +30867,7 @@ $as_echo "$ac_try_echo"; } >&5
+     cat conftest.er1 >&5
+   fi
+   rm -f conftest.er1 conftest.err
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; }
+ done
+ 
+@@ -28916,7 +30875,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+@@ -28928,9 +30887,9 @@ ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
+ # Try to create an executable without -o first, disregard a.out.
+ # It will help us diagnose broken compilers, and finding out an intuition
+ # of exeext.
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+-$as_echo_n "checking whether the C compiler works... " >&6; }
+-ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
++printf %s "checking whether the C compiler works... " >&6; }
++ac_link_default=`printf "%s\n" "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
+ 
+ # The possible output files:
+ ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+@@ -28951,13 +30910,14 @@ case "(($ac_try" in
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_link_default") 2>&5
+   ac_status=$?
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+-  test $ac_status = 0; }; then :
+-  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+-# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  test $ac_status = 0; }
++then :
++  # Autoconf-2.13 could set the ac_cv_exeext variable to 'no'.
++# So ignore a value of 'no', otherwise this would lead to 'EXEEXT = no'
+ # in a Makefile.  We should not override ac_cv_exeext if it was cached,
+ # so that the user can short-circuit this test for compilers unknown to
+ # Autoconf.
+@@ -28972,12 +30932,12 @@ do
+ 	# certainly right.
+ 	break;;
+     *.* )
+-	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
++	if test ${ac_cv_exeext+y} && test "$ac_cv_exeext" != no;
+ 	then :; else
+ 	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
+ 	fi
+ 	# We set ac_cv_exeext here because the later test for it is not
+-	# safe: cross compilers may not add the suffix if given an `-o'
++	# safe: cross compilers may not add the suffix if given an '-o'
+ 	# argument, so we may need to know it at that point already.
+ 	# Even if this section looks crufty: it has the advantage of
+ 	# actually working.
+@@ -28988,48 +30948,52 @@ do
+ done
+ test "$ac_cv_exeext" = no && ac_cv_exeext=
+ 
+-else
+-  ac_file=''
++else case e in #(
++  e) ac_file='' ;;
++esac
+ fi
+-if test -z "$ac_file"; then :
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
+-$as_echo "$as_me: failed program was:" >&5
++if test -z "$ac_file"
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
++printf "%s\n" "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+ 
+-{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
++{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
++printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ as_fn_error 77 "C compiler cannot create executables
+-See \`config.log' for more details" "$LINENO" 5; }
+-else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++See 'config.log' for more details" "$LINENO" 5; }
++else case e in #(
++  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; } ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+-$as_echo_n "checking for C compiler default output file name... " >&6; }
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+-$as_echo "$ac_file" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
++printf %s "checking for C compiler default output file name... " >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
++printf "%s\n" "$ac_file" >&6; }
+ ac_exeext=$ac_cv_exeext
+ 
+ rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
+ ac_clean_files=$ac_clean_files_save
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+-$as_echo_n "checking for suffix of executables... " >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
++printf %s "checking for suffix of executables... " >&6; }
+ if { { ac_try="$ac_link"
+ case "(($ac_try" in
+   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_link") 2>&5
+   ac_status=$?
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+-  test $ac_status = 0; }; then :
+-  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+-# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+-# work properly (i.e., refer to `conftest.exe'), while it won't with
+-# `rm'.
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  test $ac_status = 0; }
++then :
++  # If both 'conftest.exe' and 'conftest' are 'present' (well, observable)
++# catch 'conftest.exe'.  For instance with Cygwin, 'ls conftest' will
++# work properly (i.e., refer to 'conftest.exe'), while it won't with
++# 'rm'.
+ for ac_file in conftest.exe conftest conftest.*; do
+   test -f "$ac_file" || continue
+   case $ac_file in
+@@ -29039,15 +31003,16 @@ for ac_file in conftest.exe conftest conftest.*; do
+     * ) break;;
+   esac
+ done
+-else
+-  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
++else case e in #(
++  e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
++printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ as_fn_error $? "cannot compute suffix of executables: cannot compile and link
+-See \`config.log' for more details" "$LINENO" 5; }
++See 'config.log' for more details" "$LINENO" 5; } ;;
++esac
+ fi
+ rm -f conftest conftest$ac_cv_exeext
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
+-$as_echo "$ac_cv_exeext" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
++printf "%s\n" "$ac_cv_exeext" >&6; }
+ 
+ rm -f conftest.$ac_ext
+ EXEEXT=$ac_cv_exeext
+@@ -29056,9 +31021,11 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ #include <stdio.h>
+ int
+-main ()
++main (void)
+ {
+ FILE *f = fopen ("conftest.out", "w");
++ if (!f)
++  return 1;
+  return ferror (f) || fclose (f) != 0;
+ 
+   ;
+@@ -29068,8 +31035,8 @@ _ACEOF
+ ac_clean_files="$ac_clean_files conftest.out"
+ # Check that the compiler produces executables we can run.  If not, either
+ # the compiler is broken, or we cross compile.
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+-$as_echo_n "checking whether we are cross compiling... " >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
++printf %s "checking whether we are cross compiling... " >&6; }
+ if test "$cross_compiling" != yes; then
+   { { ac_try="$ac_link"
+ case "(($ac_try" in
+@@ -29077,10 +31044,10 @@ case "(($ac_try" in
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_link") 2>&5
+   ac_status=$?
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; }
+   if { ac_try='./conftest$ac_cv_exeext'
+   { { case "(($ac_try" in
+@@ -29088,39 +31055,41 @@ $as_echo "$ac_try_echo"; } >&5
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_try") 2>&5
+   ac_status=$?
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; }; }; then
+     cross_compiling=no
+   else
+     if test "$cross_compiling" = maybe; then
+ 	cross_compiling=yes
+     else
+-	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+-as_fn_error $? "cannot run C compiled programs.
+-If you meant to cross compile, use \`--host'.
+-See \`config.log' for more details" "$LINENO" 5; }
++	{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
++printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
++as_fn_error 77 "cannot run C compiled programs.
++If you meant to cross compile, use '--host'.
++See 'config.log' for more details" "$LINENO" 5; }
+     fi
+   fi
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
+-$as_echo "$cross_compiling" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
++printf "%s\n" "$cross_compiling" >&6; }
+ 
+-rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
++rm -f conftest.$ac_ext conftest$ac_cv_exeext \
++  conftest.o conftest.obj conftest.out
+ ac_clean_files=$ac_clean_files_save
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+-$as_echo_n "checking for suffix of object files... " >&6; }
+-if ${ac_cv_objext+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
++printf %s "checking for suffix of object files... " >&6; }
++if test ${ac_cv_objext+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+@@ -29134,11 +31103,12 @@ case "(($ac_try" in
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_compile") 2>&5
+   ac_status=$?
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+-  test $ac_status = 0; }; then :
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  test $ac_status = 0; }
++then :
+   for ac_file in conftest.o conftest.obj conftest.*; do
+   test -f "$ac_file" || continue;
+   case $ac_file in
+@@ -29147,31 +31117,34 @@ $as_echo "$ac_try_echo"; } >&5
+        break;;
+   esac
+ done
+-else
+-  $as_echo "$as_me: failed program was:" >&5
++else case e in #(
++  e) printf "%s\n" "$as_me: failed program was:" >&5
+ sed 's/^/| /' conftest.$ac_ext >&5
+ 
+-{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
++{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
++printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ as_fn_error $? "cannot compute suffix of object files: cannot compile
+-See \`config.log' for more details" "$LINENO" 5; }
++See 'config.log' for more details" "$LINENO" 5; } ;;
++esac
+ fi
+-rm -f conftest.$ac_cv_objext conftest.$ac_ext
++rm -f conftest.$ac_cv_objext conftest.$ac_ext ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
+-$as_echo "$ac_cv_objext" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
++printf "%s\n" "$ac_cv_objext" >&6; }
+ OBJEXT=$ac_cv_objext
+ ac_objext=$OBJEXT
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
+-$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
+-if ${ac_cv_c_compiler_gnu+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5
++printf %s "checking whether the compiler supports GNU C... " >&6; }
++if test ${ac_cv_c_compiler_gnu+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ #ifndef __GNUC__
+        choke me
+@@ -29181,30 +31154,36 @@ main ()
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_c_try_compile "$LINENO"; then :
++if ac_fn_c_try_compile "$LINENO"
++then :
+   ac_compiler_gnu=yes
+-else
+-  ac_compiler_gnu=no
++else case e in #(
++  e) ac_compiler_gnu=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+ ac_cv_c_compiler_gnu=$ac_compiler_gnu
+-
++ ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+-$as_echo "$ac_cv_c_compiler_gnu" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
++printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; }
++ac_compiler_gnu=$ac_cv_c_compiler_gnu
++
+ if test $ac_compiler_gnu = yes; then
+   GCC=yes
+ else
+   GCC=
+ fi
+-ac_test_CFLAGS=${CFLAGS+set}
++ac_test_CFLAGS=${CFLAGS+y}
+ ac_save_CFLAGS=$CFLAGS
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
+-$as_echo_n "checking whether $CC accepts -g... " >&6; }
+-if ${ac_cv_prog_cc_g+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_save_c_werror_flag=$ac_c_werror_flag
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
++printf %s "checking whether $CC accepts -g... " >&6; }
++if test ${ac_cv_prog_cc_g+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_save_c_werror_flag=$ac_c_werror_flag
+    ac_c_werror_flag=yes
+    ac_cv_prog_cc_g=no
+    CFLAGS="-g"
+@@ -29212,57 +31191,63 @@ else
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_c_try_compile "$LINENO"; then :
++if ac_fn_c_try_compile "$LINENO"
++then :
+   ac_cv_prog_cc_g=yes
+-else
+-  CFLAGS=""
++else case e in #(
++  e) CFLAGS=""
+       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_c_try_compile "$LINENO"; then :
++if ac_fn_c_try_compile "$LINENO"
++then :
+ 
+-else
+-  ac_c_werror_flag=$ac_save_c_werror_flag
++else case e in #(
++  e) ac_c_werror_flag=$ac_save_c_werror_flag
+ 	 CFLAGS="-g"
+ 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_c_try_compile "$LINENO"; then :
++if ac_fn_c_try_compile "$LINENO"
++then :
+   ac_cv_prog_cc_g=yes
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+-   ac_c_werror_flag=$ac_save_c_werror_flag
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
++   ac_c_werror_flag=$ac_save_c_werror_flag ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
+-$as_echo "$ac_cv_prog_cc_g" >&6; }
+-if test "$ac_test_CFLAGS" = set; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
++printf "%s\n" "$ac_cv_prog_cc_g" >&6; }
++if test $ac_test_CFLAGS; then
+   CFLAGS=$ac_save_CFLAGS
+ elif test $ac_cv_prog_cc_g = yes; then
+   if test "$GCC" = yes; then
+@@ -29277,94 +31262,153 @@ else
+     CFLAGS=
+   fi
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
+-$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
+-if ${ac_cv_prog_cc_c89+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_cv_prog_cc_c89=no
++ac_prog_cc_stdc=no
++if test x$ac_prog_cc_stdc = xno
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5
++printf %s "checking for $CC option to enable C11 features... " >&6; }
++if test ${ac_cv_prog_cc_c11+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_cv_prog_cc_c11=no
+ ac_save_CC=$CC
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+-#include <stdarg.h>
+-#include <stdio.h>
+-struct stat;
+-/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+-struct buf { int x; };
+-FILE * (*rcsopen) (struct buf *, struct stat *, int);
+-static char *e (p, i)
+-     char **p;
+-     int i;
+-{
+-  return p[i];
+-}
+-static char *f (char * (*g) (char **, int), char **p, ...)
+-{
+-  char *s;
+-  va_list v;
+-  va_start (v,p);
+-  s = g (p, va_arg (v,int));
+-  va_end (v);
+-  return s;
+-}
+-
+-/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+-   function prototypes and stuff, but not '\xHH' hex character constants.
+-   These don't provoke an error unfortunately, instead are silently treated
+-   as 'x'.  The following induces an error, until -std is added to get
+-   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+-   array size at least.  It's necessary to write '\x00'==0 to get something
+-   that's true only with -std.  */
+-int osf4_cc_array ['\x00' == 0 ? 1 : -1];
++$ac_c_conftest_c11_program
++_ACEOF
++for ac_arg in '' -std=gnu11
++do
++  CC="$ac_save_CC $ac_arg"
++  if ac_fn_c_try_compile "$LINENO"
++then :
++  ac_cv_prog_cc_c11=$ac_arg
++fi
++rm -f core conftest.err conftest.$ac_objext conftest.beam
++  test "x$ac_cv_prog_cc_c11" != "xno" && break
++done
++rm -f conftest.$ac_ext
++CC=$ac_save_CC ;;
++esac
++fi
+ 
+-/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+-   inside strings and character constants.  */
+-#define FOO(x) 'x'
+-int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
++if test "x$ac_cv_prog_cc_c11" = xno
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
++printf "%s\n" "unsupported" >&6; }
++else case e in #(
++  e) if test "x$ac_cv_prog_cc_c11" = x
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
++printf "%s\n" "none needed" >&6; }
++else case e in #(
++  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5
++printf "%s\n" "$ac_cv_prog_cc_c11" >&6; }
++     CC="$CC $ac_cv_prog_cc_c11" ;;
++esac
++fi
++  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11
++  ac_prog_cc_stdc=c11 ;;
++esac
++fi
++fi
++if test x$ac_prog_cc_stdc = xno
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5
++printf %s "checking for $CC option to enable C99 features... " >&6; }
++if test ${ac_cv_prog_cc_c99+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_cv_prog_cc_c99=no
++ac_save_CC=$CC
++cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++/* end confdefs.h.  */
++$ac_c_conftest_c99_program
++_ACEOF
++for ac_arg in '' -std=gnu99 -std=c99 -c99 -qlanglvl=extc1x -qlanglvl=extc99 -AC99 -D_STDC_C99=
++do
++  CC="$ac_save_CC $ac_arg"
++  if ac_fn_c_try_compile "$LINENO"
++then :
++  ac_cv_prog_cc_c99=$ac_arg
++fi
++rm -f core conftest.err conftest.$ac_objext conftest.beam
++  test "x$ac_cv_prog_cc_c99" != "xno" && break
++done
++rm -f conftest.$ac_ext
++CC=$ac_save_CC ;;
++esac
++fi
+ 
+-int test (int i, double x);
+-struct s1 {int (*f) (int a);};
+-struct s2 {int (*f) (double a);};
+-int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+-int argc;
+-char **argv;
+-int
+-main ()
+-{
+-return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+-  ;
+-  return 0;
+-}
++if test "x$ac_cv_prog_cc_c99" = xno
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
++printf "%s\n" "unsupported" >&6; }
++else case e in #(
++  e) if test "x$ac_cv_prog_cc_c99" = x
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
++printf "%s\n" "none needed" >&6; }
++else case e in #(
++  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
++printf "%s\n" "$ac_cv_prog_cc_c99" >&6; }
++     CC="$CC $ac_cv_prog_cc_c99" ;;
++esac
++fi
++  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
++  ac_prog_cc_stdc=c99 ;;
++esac
++fi
++fi
++if test x$ac_prog_cc_stdc = xno
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5
++printf %s "checking for $CC option to enable C89 features... " >&6; }
++if test ${ac_cv_prog_cc_c89+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_cv_prog_cc_c89=no
++ac_save_CC=$CC
++cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++/* end confdefs.h.  */
++$ac_c_conftest_c89_program
+ _ACEOF
+-for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+-	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
++for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+ do
+   CC="$ac_save_CC $ac_arg"
+-  if ac_fn_c_try_compile "$LINENO"; then :
++  if ac_fn_c_try_compile "$LINENO"
++then :
+   ac_cv_prog_cc_c89=$ac_arg
+ fi
+-rm -f core conftest.err conftest.$ac_objext
++rm -f core conftest.err conftest.$ac_objext conftest.beam
+   test "x$ac_cv_prog_cc_c89" != "xno" && break
+ done
+ rm -f conftest.$ac_ext
+-CC=$ac_save_CC
++CC=$ac_save_CC ;;
++esac
++fi
+ 
++if test "x$ac_cv_prog_cc_c89" = xno
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
++printf "%s\n" "unsupported" >&6; }
++else case e in #(
++  e) if test "x$ac_cv_prog_cc_c89" = x
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
++printf "%s\n" "none needed" >&6; }
++else case e in #(
++  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
++printf "%s\n" "$ac_cv_prog_cc_c89" >&6; }
++     CC="$CC $ac_cv_prog_cc_c89" ;;
++esac
+ fi
+-# AC_CACHE_VAL
+-case "x$ac_cv_prog_cc_c89" in
+-  x)
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+-$as_echo "none needed" >&6; } ;;
+-  xno)
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+-$as_echo "unsupported" >&6; } ;;
+-  *)
+-    CC="$CC $ac_cv_prog_cc_c89"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+-$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
++  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
++  ac_prog_cc_stdc=c89 ;;
+ esac
+-if test "x$ac_cv_prog_cc_c89" != xno; then :
+-
++fi
+ fi
+ 
+ ac_ext=cpp
+@@ -29380,8 +31424,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   if test "x$CXX" != x; then
+     # User has supplied compiler name already, always let that override.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied compiler CXX=$CXX" >&5
+-$as_echo "$as_me: Will use user supplied compiler CXX=$CXX" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied compiler CXX=$CXX" >&5
++printf "%s\n" "$as_me: Will use user supplied compiler CXX=$CXX" >&6;}
+     if test "x`basename $CXX`" = "x$CXX"; then
+       # A command without a complete path is provided, search $PATH.
+ 
+@@ -29389,12 +31433,13 @@ $as_echo "$as_me: Will use user supplied compiler CXX=$CXX" >&6;}
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_POTENTIAL_CXX+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $POTENTIAL_CXX in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_POTENTIAL_CXX+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $POTENTIAL_CXX in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_POTENTIAL_CXX="$POTENTIAL_CXX" # Let the user override the test with a path.
+   ;;
+@@ -29403,11 +31448,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_POTENTIAL_CXX="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_POTENTIAL_CXX="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -29415,15 +31464,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ POTENTIAL_CXX=$ac_cv_path_POTENTIAL_CXX
+ if test -n "$POTENTIAL_CXX"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CXX" >&5
+-$as_echo "$POTENTIAL_CXX" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CXX" >&5
++printf "%s\n" "$POTENTIAL_CXX" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -29463,12 +31513,13 @@ done
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_TOOLCHAIN_PATH_CXX+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $TOOLCHAIN_PATH_CXX in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_TOOLCHAIN_PATH_CXX+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $TOOLCHAIN_PATH_CXX in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_TOOLCHAIN_PATH_CXX="$TOOLCHAIN_PATH_CXX" # Let the user override the test with a path.
+   ;;
+@@ -29477,11 +31528,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_TOOLCHAIN_PATH_CXX="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_TOOLCHAIN_PATH_CXX="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -29489,15 +31544,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ TOOLCHAIN_PATH_CXX=$ac_cv_path_TOOLCHAIN_PATH_CXX
+ if test -n "$TOOLCHAIN_PATH_CXX"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH_CXX" >&5
+-$as_echo "$TOOLCHAIN_PATH_CXX" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH_CXX" >&5
++printf "%s\n" "$TOOLCHAIN_PATH_CXX" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -29515,12 +31571,13 @@ done
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_POTENTIAL_CXX+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $POTENTIAL_CXX in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_POTENTIAL_CXX+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $POTENTIAL_CXX in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_POTENTIAL_CXX="$POTENTIAL_CXX" # Let the user override the test with a path.
+   ;;
+@@ -29529,11 +31586,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_POTENTIAL_CXX="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_POTENTIAL_CXX="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -29541,15 +31602,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ POTENTIAL_CXX=$ac_cv_path_POTENTIAL_CXX
+ if test -n "$POTENTIAL_CXX"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CXX" >&5
+-$as_echo "$POTENTIAL_CXX" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CXX" >&5
++printf "%s\n" "$POTENTIAL_CXX" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -29636,12 +31698,12 @@ done
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
+     fi
+@@ -29663,10 +31725,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of CXX, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CXX, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
+     fi
+   else
+@@ -29776,12 +31838,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
+     fi
+@@ -29853,12 +31915,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
+     fi
+@@ -29873,14 +31935,14 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     CXX="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CXX to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting CXX to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CXX to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting CXX to \"$new_complete\"" >&6;}
+   fi
+ 
+   TEST_COMPILER="$CXX"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking resolved symbolic links for CXX" >&5
+-$as_echo_n "checking resolved symbolic links for CXX... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking resolved symbolic links for CXX" >&5
++printf %s "checking resolved symbolic links for CXX... " >&6; }
+   SYMLINK_ORIGINAL="$TEST_COMPILER"
+ 
+   if test "x$OPENJDK_BUILD_OS" != xwindows; then
+@@ -29931,17 +31993,17 @@ $as_echo_n "checking resolved symbolic links for CXX... " >&6; }
+   fi
+ 
+   if test "x$TEST_COMPILER" = "x$SYMLINK_ORIGINAL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no symlink" >&5
+-$as_echo "no symlink" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no symlink" >&5
++printf "%s\n" "no symlink" >&6; }
+   else
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYMLINK_ORIGINAL" >&5
+-$as_echo "$SYMLINK_ORIGINAL" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if CXX is disguised ccache" >&5
+-$as_echo_n "checking if CXX is disguised ccache... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SYMLINK_ORIGINAL" >&5
++printf "%s\n" "$SYMLINK_ORIGINAL" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if CXX is disguised ccache" >&5
++printf %s "checking if CXX is disguised ccache... " >&6; }
+     COMPILER_BASENAME=`$BASENAME "$SYMLINK_ORIGINAL"`
+     if test "x$COMPILER_BASENAME" = "xccache"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, trying to find proper $COMPILER_NAME compiler" >&5
+-$as_echo "yes, trying to find proper $COMPILER_NAME compiler" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes, trying to find proper $COMPILER_NAME compiler" >&5
++printf "%s\n" "yes, trying to find proper $COMPILER_NAME compiler" >&6; }
+       # We /usr/lib/ccache in the path, so cc is a symlink to /usr/bin/ccache.
+       # We want to control ccache invocation ourselves, so ignore this cc and try
+       # searching again.
+@@ -29956,38 +32018,44 @@ $as_echo "yes, trying to find proper $COMPILER_NAME compiler" >&6; }
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_PROPER_COMPILER_CXX+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$PROPER_COMPILER_CXX"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_PROPER_COMPILER_CXX+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$PROPER_COMPILER_CXX"; then
+   ac_cv_prog_PROPER_COMPILER_CXX="$PROPER_COMPILER_CXX" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_PROPER_COMPILER_CXX="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ PROPER_COMPILER_CXX=$ac_cv_prog_PROPER_COMPILER_CXX
+ if test -n "$PROPER_COMPILER_CXX"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CXX" >&5
+-$as_echo "$PROPER_COMPILER_CXX" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CXX" >&5
++printf "%s\n" "$PROPER_COMPILER_CXX" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -30000,38 +32068,44 @@ if test -z "$PROPER_COMPILER_CXX"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_PROPER_COMPILER_CXX+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_PROPER_COMPILER_CXX"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_PROPER_COMPILER_CXX+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_PROPER_COMPILER_CXX"; then
+   ac_cv_prog_ac_ct_PROPER_COMPILER_CXX="$ac_ct_PROPER_COMPILER_CXX" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_PROPER_COMPILER_CXX="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_PROPER_COMPILER_CXX=$ac_cv_prog_ac_ct_PROPER_COMPILER_CXX
+ if test -n "$ac_ct_PROPER_COMPILER_CXX"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_PROPER_COMPILER_CXX" >&5
+-$as_echo "$ac_ct_PROPER_COMPILER_CXX" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_PROPER_COMPILER_CXX" >&5
++printf "%s\n" "$ac_ct_PROPER_COMPILER_CXX" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -30043,8 +32117,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     PROPER_COMPILER_CXX=$ac_ct_PROPER_COMPILER_CXX
+@@ -30092,12 +32166,12 @@ fi
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CXX" "$LINENO" 5
+     fi
+@@ -30119,10 +32193,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CXX" "$LINENO" 5
+     fi
+   else
+@@ -30232,12 +32306,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CXX" "$LINENO" 5
+     fi
+@@ -30309,12 +32383,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CXX" "$LINENO" 5
+     fi
+@@ -30329,14 +32403,14 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     PROPER_COMPILER_CXX="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting PROPER_COMPILER_CXX to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting PROPER_COMPILER_CXX to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting PROPER_COMPILER_CXX to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting PROPER_COMPILER_CXX to \"$new_complete\"" >&6;}
+   fi
+ 
+       PATH="$RETRY_COMPILER_SAVED_PATH"
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for resolved symbolic links for CXX" >&5
+-$as_echo_n "checking for resolved symbolic links for CXX... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for resolved symbolic links for CXX" >&5
++printf %s "checking for resolved symbolic links for CXX... " >&6; }
+ 
+   if test "x$OPENJDK_BUILD_OS" != xwindows; then
+     # Follow a chain of symbolic links. Use readlink
+@@ -30385,12 +32459,12 @@ $as_echo_n "checking for resolved symbolic links for CXX... " >&6; }
+     fi
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CXX" >&5
+-$as_echo "$PROPER_COMPILER_CXX" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CXX" >&5
++printf "%s\n" "$PROPER_COMPILER_CXX" >&6; }
+       CXX="$PROPER_COMPILER_CXX"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, keeping CXX" >&5
+-$as_echo "no, keeping CXX" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, keeping CXX" >&5
++printf "%s\n" "no, keeping CXX" >&6; }
+     fi
+   fi
+ 
+@@ -30406,12 +32480,12 @@ $as_echo "no, keeping CXX" >&6; }
+     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null
+     if test $? -ne 0; then
+       ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
+-$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
+-$as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
+-$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
++printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
++printf "%s\n" "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
++printf "%s\n" "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
+       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
+     fi
+     # Remove usage instructions (if present), and
+@@ -30429,12 +32503,12 @@ $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUT
+     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
+     if test $? -ne 0; then
+       ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
+-$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
+-$as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
+-$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
++printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
++printf "%s\n" "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
++printf "%s\n" "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
+       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
+     fi
+     # Collapse compiler output into a single line
+@@ -30449,10 +32523,10 @@ $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUT
+     # Check that this is likely to be Microsoft CL.EXE.
+     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
+     if test $? -ne 0; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
+-$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
+-$as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
++printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
++printf "%s\n" "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
+       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
+     fi
+     # Collapse compiler output into a single line
+@@ -30469,10 +32543,10 @@ $as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\""
+     # Check that this is likely to be GCC.
+     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
+     if test $? -ne 0; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
+-$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
+-$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
++printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
++printf "%s\n" "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
+       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
+     fi
+     # Remove Copyright and legalese from version string, and
+@@ -30493,10 +32567,10 @@ $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSIO
+     # Check that this is likely to be clang
+     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
+     if test $? -ne 0; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
+-$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
+-$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
++printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
++printf "%s\n" "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
+       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
+     fi
+     # Collapse compiler output into a single line
+@@ -30512,8 +32586,8 @@ $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSIO
+   # This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
+   CXX_VERSION_STRING="$COMPILER_VERSION_STRING"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
+-$as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
++printf "%s\n" "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
+ 
+ 
+   # Now that we have resolved CXX ourself, let autoconf have its go at it
+@@ -30531,38 +32605,44 @@ if test -z "$CXX"; then
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_CXX+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$CXX"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_CXX+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$CXX"; then
+   ac_cv_prog_CXX="$CXX" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ CXX=$ac_cv_prog_CXX
+ if test -n "$CXX"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
+-$as_echo "$CXX" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
++printf "%s\n" "$CXX" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -30575,38 +32655,44 @@ if test -z "$CXX"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_CXX+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_CXX"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_CXX+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_CXX"; then
+   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_CXX="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
+ if test -n "$ac_ct_CXX"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
+-$as_echo "$ac_ct_CXX" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
++printf "%s\n" "$ac_ct_CXX" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -30618,8 +32704,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     CXX=$ac_ct_CXX
+@@ -30629,7 +32715,7 @@ fi
+   fi
+ fi
+ # Provide some information about the compiler.
+-$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
++printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
+ set X $ac_compile
+ ac_compiler=$2
+ for ac_option in --version -v -V -qversion; do
+@@ -30639,7 +32725,7 @@ case "(($ac_try" in
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+   ac_status=$?
+   if test -s conftest.err; then
+@@ -30649,20 +32735,21 @@ $as_echo "$ac_try_echo"; } >&5
+     cat conftest.er1 >&5
+   fi
+   rm -f conftest.er1 conftest.err
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; }
+ done
+ 
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
+-$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
+-if ${ac_cv_cxx_compiler_gnu+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C++" >&5
++printf %s "checking whether the compiler supports GNU C++... " >&6; }
++if test ${ac_cv_cxx_compiler_gnu+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ #ifndef __GNUC__
+        choke me
+@@ -30672,30 +32759,36 @@ main ()
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+   ac_compiler_gnu=yes
+-else
+-  ac_compiler_gnu=no
++else case e in #(
++  e) ac_compiler_gnu=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+ ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
+-
++ ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
+-$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
++printf "%s\n" "$ac_cv_cxx_compiler_gnu" >&6; }
++ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
++
+ if test $ac_compiler_gnu = yes; then
+   GXX=yes
+ else
+   GXX=
+ fi
+-ac_test_CXXFLAGS=${CXXFLAGS+set}
++ac_test_CXXFLAGS=${CXXFLAGS+y}
+ ac_save_CXXFLAGS=$CXXFLAGS
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
+-$as_echo_n "checking whether $CXX accepts -g... " >&6; }
+-if ${ac_cv_prog_cxx_g+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
++printf %s "checking whether $CXX accepts -g... " >&6; }
++if test ${ac_cv_prog_cxx_g+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_save_cxx_werror_flag=$ac_cxx_werror_flag
+    ac_cxx_werror_flag=yes
+    ac_cv_prog_cxx_g=no
+    CXXFLAGS="-g"
+@@ -30703,57 +32796,63 @@ else
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+   ac_cv_prog_cxx_g=yes
+-else
+-  CXXFLAGS=""
++else case e in #(
++  e) CXXFLAGS=""
+       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+ 
+-else
+-  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
++else case e in #(
++  e) ac_cxx_werror_flag=$ac_save_cxx_werror_flag
+ 	 CXXFLAGS="-g"
+ 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+   ac_cv_prog_cxx_g=yes
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+-   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
++   ac_cxx_werror_flag=$ac_save_cxx_werror_flag ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
+-$as_echo "$ac_cv_prog_cxx_g" >&6; }
+-if test "$ac_test_CXXFLAGS" = set; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
++printf "%s\n" "$ac_cv_prog_cxx_g" >&6; }
++if test $ac_test_CXXFLAGS; then
+   CXXFLAGS=$ac_save_CXXFLAGS
+ elif test $ac_cv_prog_cxx_g = yes; then
+   if test "$GXX" = yes; then
+@@ -30768,6 +32867,106 @@ else
+     CXXFLAGS=
+   fi
+ fi
++ac_prog_cxx_stdcxx=no
++if test x$ac_prog_cxx_stdcxx = xno
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++11 features" >&5
++printf %s "checking for $CXX option to enable C++11 features... " >&6; }
++if test ${ac_cv_prog_cxx_cxx11+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_cv_prog_cxx_cxx11=no
++ac_save_CXX=$CXX
++cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++/* end confdefs.h.  */
++$ac_cxx_conftest_cxx11_program
++_ACEOF
++for ac_arg in '' -std=gnu++11 -std=gnu++0x -std=c++11 -std=c++0x -qlanglvl=extended0x -AA
++do
++  CXX="$ac_save_CXX $ac_arg"
++  if ac_fn_cxx_try_compile "$LINENO"
++then :
++  ac_cv_prog_cxx_cxx11=$ac_arg
++fi
++rm -f core conftest.err conftest.$ac_objext conftest.beam
++  test "x$ac_cv_prog_cxx_cxx11" != "xno" && break
++done
++rm -f conftest.$ac_ext
++CXX=$ac_save_CXX ;;
++esac
++fi
++
++if test "x$ac_cv_prog_cxx_cxx11" = xno
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
++printf "%s\n" "unsupported" >&6; }
++else case e in #(
++  e) if test "x$ac_cv_prog_cxx_cxx11" = x
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
++printf "%s\n" "none needed" >&6; }
++else case e in #(
++  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx11" >&5
++printf "%s\n" "$ac_cv_prog_cxx_cxx11" >&6; }
++     CXX="$CXX $ac_cv_prog_cxx_cxx11" ;;
++esac
++fi
++  ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11
++  ac_prog_cxx_stdcxx=cxx11 ;;
++esac
++fi
++fi
++if test x$ac_prog_cxx_stdcxx = xno
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++98 features" >&5
++printf %s "checking for $CXX option to enable C++98 features... " >&6; }
++if test ${ac_cv_prog_cxx_cxx98+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_cv_prog_cxx_cxx98=no
++ac_save_CXX=$CXX
++cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++/* end confdefs.h.  */
++$ac_cxx_conftest_cxx98_program
++_ACEOF
++for ac_arg in '' -std=gnu++98 -std=c++98 -qlanglvl=extended -AA
++do
++  CXX="$ac_save_CXX $ac_arg"
++  if ac_fn_cxx_try_compile "$LINENO"
++then :
++  ac_cv_prog_cxx_cxx98=$ac_arg
++fi
++rm -f core conftest.err conftest.$ac_objext conftest.beam
++  test "x$ac_cv_prog_cxx_cxx98" != "xno" && break
++done
++rm -f conftest.$ac_ext
++CXX=$ac_save_CXX ;;
++esac
++fi
++
++if test "x$ac_cv_prog_cxx_cxx98" = xno
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
++printf "%s\n" "unsupported" >&6; }
++else case e in #(
++  e) if test "x$ac_cv_prog_cxx_cxx98" = x
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
++printf "%s\n" "none needed" >&6; }
++else case e in #(
++  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx98" >&5
++printf "%s\n" "$ac_cv_prog_cxx_cxx98" >&6; }
++     CXX="$CXX $ac_cv_prog_cxx_cxx98" ;;
++esac
++fi
++  ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98
++  ac_prog_cxx_stdcxx=cxx98 ;;
++esac
++fi
++fi
++
+ ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -30781,21 +32980,21 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+ 
+   if test "x$CC_VERSION_NUMBER" != "x$CXX_VERSION_NUMBER"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler has different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&5
+-$as_echo "$as_me: WARNING: C and C++ compiler has different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&2;}
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This typically indicates a broken setup, and is not supported" >&5
+-$as_echo "$as_me: WARNING: This typically indicates a broken setup, and is not supported" >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler has different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&5
++printf "%s\n" "$as_me: WARNING: C and C++ compiler has different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: This typically indicates a broken setup, and is not supported" >&5
++printf "%s\n" "$as_me: WARNING: This typically indicates a broken setup, and is not supported" >&2;}
+   fi
+ 
+   # We only check CC_VERSION_NUMBER since we assume CXX_VERSION_NUMBER is equal.
+   if  [[ "$CC_VERSION_NUMBER" =~ (.*\.){3} ]] ; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION. Comparisons might be wrong." >&5
+-$as_echo "$as_me: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION. Comparisons might be wrong." >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION. Comparisons might be wrong." >&5
++printf "%s\n" "$as_me: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION. Comparisons might be wrong." >&2;}
+   fi
+ 
+   if  [[  "$CC_VERSION_NUMBER" =~ [0-9]{6} ]] ; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION. Comparisons might be wrong." >&5
+-$as_echo "$as_me: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION. Comparisons might be wrong." >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION. Comparisons might be wrong." >&5
++printf "%s\n" "$as_me: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION. Comparisons might be wrong." >&2;}
+   fi
+ 
+   COMPARABLE_ACTUAL_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$CC_VERSION_NUMBER"`
+@@ -30809,42 +33008,39 @@ ac_cpp='$CPP $CPPFLAGS'
+ ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+-$as_echo_n "checking how to run the C preprocessor... " >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
++printf %s "checking how to run the C preprocessor... " >&6; }
+ # On Suns, sometimes $CPP names a directory.
+ if test -n "$CPP" && test -d "$CPP"; then
+   CPP=
+ fi
+ if test -z "$CPP"; then
+-  if ${ac_cv_prog_CPP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-      # Double quotes because CPP needs to be expanded
+-    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
++  if test ${ac_cv_prog_CPP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e)     # Double quotes because $CC needs to be expanded
++    for CPP in "$CC -E" "$CC -E -traditional-cpp" cpp /lib/cpp
+     do
+       ac_preproc_ok=false
+ for ac_c_preproc_warn_flag in '' yes
+ do
+   # Use a header file that comes with gcc, so configuring glibc
+   # with a fresh cross-compiler works.
+-  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+-  # <limits.h> exists even on freestanding compilers.
+   # On the NeXT, cc -E runs the code through the compiler's parser,
+   # not just through cpp. "Syntax error" is here to catch this case.
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+-#ifdef __STDC__
+-# include <limits.h>
+-#else
+-# include <assert.h>
+-#endif
++#include <limits.h>
+ 		     Syntax error
+ _ACEOF
+-if ac_fn_c_try_cpp "$LINENO"; then :
++if ac_fn_c_try_cpp "$LINENO"
++then :
+ 
+-else
+-  # Broken: fails on valid input.
+-continue
++else case e in #(
++  e) # Broken: fails on valid input.
++continue ;;
++esac
+ fi
+ rm -f conftest.err conftest.i conftest.$ac_ext
+ 
+@@ -30854,56 +33050,56 @@ rm -f conftest.err conftest.i conftest.$ac_ext
+ /* end confdefs.h.  */
+ #include <ac_nonexistent.h>
+ _ACEOF
+-if ac_fn_c_try_cpp "$LINENO"; then :
++if ac_fn_c_try_cpp "$LINENO"
++then :
+   # Broken: success on invalid input.
+ continue
+-else
+-  # Passes both tests.
++else case e in #(
++  e) # Passes both tests.
+ ac_preproc_ok=:
+-break
++break ;;
++esac
+ fi
+ rm -f conftest.err conftest.i conftest.$ac_ext
+ 
+ done
+-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
++# Because of 'break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+ rm -f conftest.i conftest.err conftest.$ac_ext
+-if $ac_preproc_ok; then :
++if $ac_preproc_ok
++then :
+   break
+ fi
+ 
+     done
+     ac_cv_prog_CPP=$CPP
+-
++   ;;
++esac
+ fi
+   CPP=$ac_cv_prog_CPP
+ else
+   ac_cv_prog_CPP=$CPP
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+-$as_echo "$CPP" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
++printf "%s\n" "$CPP" >&6; }
+ ac_preproc_ok=false
+ for ac_c_preproc_warn_flag in '' yes
+ do
+   # Use a header file that comes with gcc, so configuring glibc
+   # with a fresh cross-compiler works.
+-  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+-  # <limits.h> exists even on freestanding compilers.
+   # On the NeXT, cc -E runs the code through the compiler's parser,
+   # not just through cpp. "Syntax error" is here to catch this case.
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+-#ifdef __STDC__
+-# include <limits.h>
+-#else
+-# include <assert.h>
+-#endif
++#include <limits.h>
+ 		     Syntax error
+ _ACEOF
+-if ac_fn_c_try_cpp "$LINENO"; then :
++if ac_fn_c_try_cpp "$LINENO"
++then :
+ 
+-else
+-  # Broken: fails on valid input.
+-continue
++else case e in #(
++  e) # Broken: fails on valid input.
++continue ;;
++esac
+ fi
+ rm -f conftest.err conftest.i conftest.$ac_ext
+ 
+@@ -30913,26 +33109,30 @@ rm -f conftest.err conftest.i conftest.$ac_ext
+ /* end confdefs.h.  */
+ #include <ac_nonexistent.h>
+ _ACEOF
+-if ac_fn_c_try_cpp "$LINENO"; then :
++if ac_fn_c_try_cpp "$LINENO"
++then :
+   # Broken: success on invalid input.
+ continue
+-else
+-  # Passes both tests.
++else case e in #(
++  e) # Passes both tests.
+ ac_preproc_ok=:
+-break
++break ;;
++esac
+ fi
+ rm -f conftest.err conftest.i conftest.$ac_ext
+ 
+ done
+-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
++# Because of 'break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+ rm -f conftest.i conftest.err conftest.$ac_ext
+-if $ac_preproc_ok; then :
++if $ac_preproc_ok
++then :
+ 
+-else
+-  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
++else case e in #(
++  e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
++printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
+-See \`config.log' for more details" "$LINENO" 5; }
++See 'config.log' for more details" "$LINENO" 5; } ;;
++esac
+ fi
+ 
+ ac_ext=cpp
+@@ -30982,12 +33182,12 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
+     fi
+@@ -31009,10 +33209,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of CPP, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CPP, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
+     fi
+   else
+@@ -31122,12 +33322,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
+     fi
+@@ -31199,12 +33399,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
+     fi
+@@ -31219,8 +33419,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     CPP="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CPP to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting CPP to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CPP to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting CPP to \"$new_complete\"" >&6;}
+   fi
+ 
+   ac_ext=cpp
+@@ -31228,38 +33428,35 @@ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
+-$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
++printf %s "checking how to run the C++ preprocessor... " >&6; }
+ if test -z "$CXXCPP"; then
+-  if ${ac_cv_prog_CXXCPP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-      # Double quotes because CXXCPP needs to be expanded
+-    for CXXCPP in "$CXX -E" "/lib/cpp"
++  if test ${ac_cv_prog_CXXCPP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e)     # Double quotes because $CXX needs to be expanded
++    for CXXCPP in "$CXX -E" cpp /lib/cpp
+     do
+       ac_preproc_ok=false
+ for ac_cxx_preproc_warn_flag in '' yes
+ do
+   # Use a header file that comes with gcc, so configuring glibc
+   # with a fresh cross-compiler works.
+-  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+-  # <limits.h> exists even on freestanding compilers.
+   # On the NeXT, cc -E runs the code through the compiler's parser,
+   # not just through cpp. "Syntax error" is here to catch this case.
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+-#ifdef __STDC__
+-# include <limits.h>
+-#else
+-# include <assert.h>
+-#endif
++#include <limits.h>
+ 		     Syntax error
+ _ACEOF
+-if ac_fn_cxx_try_cpp "$LINENO"; then :
++if ac_fn_cxx_try_cpp "$LINENO"
++then :
+ 
+-else
+-  # Broken: fails on valid input.
+-continue
++else case e in #(
++  e) # Broken: fails on valid input.
++continue ;;
++esac
+ fi
+ rm -f conftest.err conftest.i conftest.$ac_ext
+ 
+@@ -31269,56 +33466,56 @@ rm -f conftest.err conftest.i conftest.$ac_ext
+ /* end confdefs.h.  */
+ #include <ac_nonexistent.h>
+ _ACEOF
+-if ac_fn_cxx_try_cpp "$LINENO"; then :
++if ac_fn_cxx_try_cpp "$LINENO"
++then :
+   # Broken: success on invalid input.
+ continue
+-else
+-  # Passes both tests.
++else case e in #(
++  e) # Passes both tests.
+ ac_preproc_ok=:
+-break
++break ;;
++esac
+ fi
+ rm -f conftest.err conftest.i conftest.$ac_ext
+ 
+ done
+-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
++# Because of 'break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+ rm -f conftest.i conftest.err conftest.$ac_ext
+-if $ac_preproc_ok; then :
++if $ac_preproc_ok
++then :
+   break
+ fi
+ 
+     done
+     ac_cv_prog_CXXCPP=$CXXCPP
+-
++   ;;
++esac
+ fi
+   CXXCPP=$ac_cv_prog_CXXCPP
+ else
+   ac_cv_prog_CXXCPP=$CXXCPP
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
+-$as_echo "$CXXCPP" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
++printf "%s\n" "$CXXCPP" >&6; }
+ ac_preproc_ok=false
+ for ac_cxx_preproc_warn_flag in '' yes
+ do
+   # Use a header file that comes with gcc, so configuring glibc
+   # with a fresh cross-compiler works.
+-  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+-  # <limits.h> exists even on freestanding compilers.
+   # On the NeXT, cc -E runs the code through the compiler's parser,
+   # not just through cpp. "Syntax error" is here to catch this case.
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+-#ifdef __STDC__
+-# include <limits.h>
+-#else
+-# include <assert.h>
+-#endif
++#include <limits.h>
+ 		     Syntax error
+ _ACEOF
+-if ac_fn_cxx_try_cpp "$LINENO"; then :
++if ac_fn_cxx_try_cpp "$LINENO"
++then :
+ 
+-else
+-  # Broken: fails on valid input.
+-continue
++else case e in #(
++  e) # Broken: fails on valid input.
++continue ;;
++esac
+ fi
+ rm -f conftest.err conftest.i conftest.$ac_ext
+ 
+@@ -31328,26 +33525,30 @@ rm -f conftest.err conftest.i conftest.$ac_ext
+ /* end confdefs.h.  */
+ #include <ac_nonexistent.h>
+ _ACEOF
+-if ac_fn_cxx_try_cpp "$LINENO"; then :
++if ac_fn_cxx_try_cpp "$LINENO"
++then :
+   # Broken: success on invalid input.
+ continue
+-else
+-  # Passes both tests.
++else case e in #(
++  e) # Passes both tests.
+ ac_preproc_ok=:
+-break
++break ;;
++esac
+ fi
+ rm -f conftest.err conftest.i conftest.$ac_ext
+ 
+ done
+-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
++# Because of 'break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+ rm -f conftest.i conftest.err conftest.$ac_ext
+-if $ac_preproc_ok; then :
++if $ac_preproc_ok
++then :
+ 
+-else
+-  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
++else case e in #(
++  e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
++printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
+-See \`config.log' for more details" "$LINENO" 5; }
++See 'config.log' for more details" "$LINENO" 5; } ;;
++esac
+ fi
+ 
+ ac_ext=cpp
+@@ -31397,12 +33598,12 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
+     fi
+@@ -31424,10 +33625,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of CXXCPP, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CXXCPP, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
+     fi
+   else
+@@ -31537,12 +33738,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
+     fi
+@@ -31614,12 +33815,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
+     fi
+@@ -31634,8 +33835,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     CXXCPP="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CXXCPP to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting CXXCPP to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CXXCPP to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting CXXCPP to \"$new_complete\"" >&6;}
+   fi
+ 
+ 
+@@ -31648,12 +33849,13 @@ $as_echo "$as_me: Rewriting CXXCPP to \"$new_complete\"" >&6;}
+     # a cygwin program for something completely different.
+     # Extract the first word of "link", so it can be a program name with args.
+ set dummy link; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_LD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$LD"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_LD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$LD"; then
+   ac_cv_prog_LD="$LD" # Let the user override the test.
+ else
+   ac_prog_rejected=no
+@@ -31661,15 +33863,19 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    if test "$as_dir/$ac_word$ac_exec_ext" = "$CYGWIN_LINK"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    if test "$as_dir$ac_word$ac_exec_ext" = "$CYGWIN_LINK"; then
+        ac_prog_rejected=yes
+        continue
+      fi
+     ac_cv_prog_LD="link"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -31685,18 +33891,19 @@ if test $ac_prog_rejected = yes; then
+     # However, it has the same basename, so the bogon will be chosen
+     # first if we set LD to just the basename; use the full file name.
+     shift
+-    ac_cv_prog_LD="$as_dir/$ac_word${1+' '}$@"
++    ac_cv_prog_LD="$as_dir$ac_word${1+' '}$@"
+   fi
+ fi
+-fi
++fi ;;
++esac
+ fi
+ LD=$ac_cv_prog_LD
+ if test -n "$LD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
+-$as_echo "$LD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
++printf "%s\n" "$LD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -31741,12 +33948,12 @@ fi
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
+     fi
+@@ -31768,10 +33975,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of LD, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of LD, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
+     fi
+   else
+@@ -31881,12 +34088,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
+     fi
+@@ -31958,12 +34165,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
+     fi
+@@ -31978,21 +34185,21 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     LD="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting LD to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting LD to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting LD to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting LD to \"$new_complete\"" >&6;}
+   fi
+ 
+     # Verify that we indeed succeeded with this trick.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the found link.exe is actually the Visual Studio linker" >&5
+-$as_echo_n "checking if the found link.exe is actually the Visual Studio linker... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the found link.exe is actually the Visual Studio linker" >&5
++printf %s "checking if the found link.exe is actually the Visual Studio linker... " >&6; }
+     "$LD" --version > /dev/null
+     if test $? -eq 0 ; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+       as_fn_error $? "This is the Cygwin link tool. Please check your PATH and rerun configure." "$LINENO" 5
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+     fi
+     LDCXX="$LD"
+   else
+@@ -32020,12 +34227,13 @@ $as_echo "yes" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_AS+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $AS in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_AS+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $AS in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_AS="$AS" # Let the user override the test with a path.
+   ;;
+@@ -32034,11 +34242,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_AS="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -32046,15 +34258,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ AS=$ac_cv_path_AS
+ if test -n "$AS"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
+-$as_echo "$AS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
++printf "%s\n" "$AS" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -32070,20 +34283,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xAS" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in as
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_AS+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $AS in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_AS+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $AS in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_AS="$AS" # Let the user override the test with a path.
+   ;;
+@@ -32092,11 +34306,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_AS="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -32104,15 +34322,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ AS=$ac_cv_path_AS
+ if test -n "$AS"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
+-$as_echo "$AS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
++printf "%s\n" "$AS" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -32132,16 +34351,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AS=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool AS=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AS=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool AS=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_AS+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $AS in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_AS+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $AS in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_AS="$AS" # Let the user override the test with a path.
+   ;;
+@@ -32150,11 +34370,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_AS="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -32162,15 +34386,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ AS=$ac_cv_path_AS
+ if test -n "$AS"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
+-$as_echo "$AS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
++printf "%s\n" "$AS" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -32179,17 +34404,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AS=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool AS=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AS" >&5
+-$as_echo_n "checking for AS... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AS=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool AS=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for AS" >&5
++printf %s "checking for AS... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool AS=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -32236,12 +34461,12 @@ $as_echo "$tool_specified" >&6; }
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
+     fi
+@@ -32263,10 +34488,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of AS, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of AS, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
+     fi
+   else
+@@ -32376,12 +34601,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
+     fi
+@@ -32453,12 +34678,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
+     fi
+@@ -32473,8 +34698,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     AS="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting AS to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting AS to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting AS to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting AS to \"$new_complete\"" >&6;}
+   fi
+ 
+   else
+@@ -32490,38 +34715,44 @@ $as_echo "$as_me: Rewriting AS to \"$new_complete\"" >&6;}
+     # The corresponding ar tool is lib.exe (used to create static libraries)
+     # Extract the first word of "lib", so it can be a program name with args.
+ set dummy lib; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_AR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$AR"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_AR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$AR"; then
+   ac_cv_prog_AR="$AR" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_AR="lib"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ AR=$ac_cv_prog_AR
+ if test -n "$AR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
+-$as_echo "$AR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
++printf "%s\n" "$AR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -32538,38 +34769,44 @@ fi
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_AR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$AR"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_AR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$AR"; then
+   ac_cv_prog_AR="$AR" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ AR=$ac_cv_prog_AR
+ if test -n "$AR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
+-$as_echo "$AR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
++printf "%s\n" "$AR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -32582,38 +34819,44 @@ if test -z "$AR"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_AR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_AR"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_AR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_AR"; then
+   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_AR="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_AR=$ac_cv_prog_ac_ct_AR
+ if test -n "$ac_ct_AR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
+-$as_echo "$ac_ct_AR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
++printf "%s\n" "$ac_ct_AR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -32625,8 +34868,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     AR=$ac_ct_AR
+@@ -32642,8 +34885,8 @@ fi
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xAR" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       if test -n "$ac_tool_prefix"; then
+@@ -32651,38 +34894,44 @@ $as_echo "$as_me: WARNING: Ignoring value of AR from the environment. Use comman
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_AR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$AR"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_AR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$AR"; then
+   ac_cv_prog_AR="$AR" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ AR=$ac_cv_prog_AR
+ if test -n "$AR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
+-$as_echo "$AR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
++printf "%s\n" "$AR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -32695,38 +34944,44 @@ if test -z "$AR"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_AR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_AR"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_AR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_AR"; then
+   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_AR="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_AR=$ac_cv_prog_ac_ct_AR
+ if test -n "$ac_ct_AR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
+-$as_echo "$ac_ct_AR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
++printf "%s\n" "$ac_ct_AR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -32738,8 +34993,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     AR=$ac_ct_AR
+@@ -32759,16 +35014,17 @@ fi
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AR=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool AR=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AR=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool AR=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_AR+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $AR in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_AR+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $AR in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_AR="$AR" # Let the user override the test with a path.
+   ;;
+@@ -32777,11 +35033,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_AR="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_AR="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -32789,15 +35049,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ AR=$ac_cv_path_AR
+ if test -n "$AR"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
+-$as_echo "$AR" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
++printf "%s\n" "$AR" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -32806,17 +35067,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AR=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool AR=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AR" >&5
+-$as_echo_n "checking for AR... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AR=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool AR=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for AR" >&5
++printf %s "checking for AR... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool AR=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -32864,12 +35125,12 @@ $as_echo "$tool_specified" >&6; }
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
+     fi
+@@ -32891,10 +35152,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of AR, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of AR, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
+     fi
+   else
+@@ -33004,12 +35265,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
+     fi
+@@ -33081,12 +35342,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
+     fi
+@@ -33101,8 +35362,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     AR="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting AR to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting AR to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting AR to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting AR to \"$new_complete\"" >&6;}
+   fi
+ 
+ 
+@@ -33114,42 +35375,48 @@ ac_compile='$OBJC -c $OBJCFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ ac_link='$OBJC -o conftest$ac_exeext $OBJCFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ ac_compiler_gnu=$ac_cv_objc_compiler_gnu
+ if test -n "$ac_tool_prefix"; then
+-  for ac_prog in gcc objcc objc cc CC
++  for ac_prog in gcc objcc objc cc CC clang
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_OBJC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$OBJC"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_OBJC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$OBJC"; then
+   ac_cv_prog_OBJC="$OBJC" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_OBJC="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ OBJC=$ac_cv_prog_OBJC
+ if test -n "$OBJC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJC" >&5
+-$as_echo "$OBJC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJC" >&5
++printf "%s\n" "$OBJC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -33158,42 +35425,48 @@ fi
+ fi
+ if test -z "$OBJC"; then
+   ac_ct_OBJC=$OBJC
+-  for ac_prog in gcc objcc objc cc CC
++  for ac_prog in gcc objcc objc cc CC clang
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_OBJC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_OBJC"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_OBJC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_OBJC"; then
+   ac_cv_prog_ac_ct_OBJC="$ac_ct_OBJC" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_OBJC="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_OBJC=$ac_cv_prog_ac_ct_OBJC
+ if test -n "$ac_ct_OBJC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJC" >&5
+-$as_echo "$ac_ct_OBJC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJC" >&5
++printf "%s\n" "$ac_ct_OBJC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -33205,8 +35478,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     OBJC=$ac_ct_OBJC
+@@ -33214,7 +35487,7 @@ esac
+ fi
+ 
+ # Provide some information about the compiler.
+-$as_echo "$as_me:${as_lineno-$LINENO}: checking for Objective C compiler version" >&5
++printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Objective C compiler version" >&5
+ set X $ac_compile
+ ac_compiler=$2
+ for ac_option in --version -v -V -qversion; do
+@@ -33224,7 +35497,7 @@ case "(($ac_try" in
+   *) ac_try_echo=$ac_try;;
+ esac
+ eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+-$as_echo "$ac_try_echo"; } >&5
++printf "%s\n" "$ac_try_echo"; } >&5
+   (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+   ac_status=$?
+   if test -s conftest.err; then
+@@ -33234,20 +35507,21 @@ $as_echo "$ac_try_echo"; } >&5
+     cat conftest.er1 >&5
+   fi
+   rm -f conftest.er1 conftest.err
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; }
+ done
+ 
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Objective C compiler" >&5
+-$as_echo_n "checking whether we are using the GNU Objective C compiler... " >&6; }
+-if ${ac_cv_objc_compiler_gnu+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU Objective C" >&5
++printf %s "checking whether the compiler supports GNU Objective C... " >&6; }
++if test ${ac_cv_objc_compiler_gnu+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ #ifndef __GNUC__
+        choke me
+@@ -33257,30 +35531,36 @@ main ()
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_objc_try_compile "$LINENO"; then :
++if ac_fn_objc_try_compile "$LINENO"
++then :
+   ac_compiler_gnu=yes
+-else
+-  ac_compiler_gnu=no
++else case e in #(
++  e) ac_compiler_gnu=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+ ac_cv_objc_compiler_gnu=$ac_compiler_gnu
+-
++ ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objc_compiler_gnu" >&5
+-$as_echo "$ac_cv_objc_compiler_gnu" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objc_compiler_gnu" >&5
++printf "%s\n" "$ac_cv_objc_compiler_gnu" >&6; }
++ac_compiler_gnu=$ac_cv_objc_compiler_gnu
++
+ if test $ac_compiler_gnu = yes; then
+   GOBJC=yes
+ else
+   GOBJC=
+ fi
+-ac_test_OBJCFLAGS=${OBJCFLAGS+set}
++ac_test_OBJCFLAGS=${OBJCFLAGS+y}
+ ac_save_OBJCFLAGS=$OBJCFLAGS
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $OBJC accepts -g" >&5
+-$as_echo_n "checking whether $OBJC accepts -g... " >&6; }
+-if ${ac_cv_prog_objc_g+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_save_objc_werror_flag=$ac_objc_werror_flag
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $OBJC accepts -g" >&5
++printf %s "checking whether $OBJC accepts -g... " >&6; }
++if test ${ac_cv_prog_objc_g+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_save_objc_werror_flag=$ac_objc_werror_flag
+    ac_objc_werror_flag=yes
+    ac_cv_prog_objc_g=no
+    OBJCFLAGS="-g"
+@@ -33288,57 +35568,63 @@ else
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_objc_try_compile "$LINENO"; then :
++if ac_fn_objc_try_compile "$LINENO"
++then :
+   ac_cv_prog_objc_g=yes
+-else
+-  OBJCFLAGS=""
++else case e in #(
++  e) OBJCFLAGS=""
+       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_objc_try_compile "$LINENO"; then :
++if ac_fn_objc_try_compile "$LINENO"
++then :
+ 
+-else
+-  ac_objc_werror_flag=$ac_save_objc_werror_flag
++else case e in #(
++  e) ac_objc_werror_flag=$ac_save_objc_werror_flag
+ 	 OBJCFLAGS="-g"
+ 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_objc_try_compile "$LINENO"; then :
++if ac_fn_objc_try_compile "$LINENO"
++then :
+   ac_cv_prog_objc_g=yes
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+-   ac_objc_werror_flag=$ac_save_objc_werror_flag
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
++   ac_objc_werror_flag=$ac_save_objc_werror_flag ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_objc_g" >&5
+-$as_echo "$ac_cv_prog_objc_g" >&6; }
+-if test "$ac_test_OBJCFLAGS" = set; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_objc_g" >&5
++printf "%s\n" "$ac_cv_prog_objc_g" >&6; }
++if test $ac_test_OBJCFLAGS; then
+   OBJCFLAGS=$ac_save_OBJCFLAGS
+ elif test $ac_cv_prog_objc_g = yes; then
+   if test "$GOBJC" = yes; then
+@@ -33400,12 +35686,12 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of OBJC" "$LINENO" 5
+     fi
+@@ -33427,10 +35713,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of OBJC, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of OBJC, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of OBJC" "$LINENO" 5
+     fi
+   else
+@@ -33540,12 +35826,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of OBJC" "$LINENO" 5
+     fi
+@@ -33617,12 +35903,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of OBJC" "$LINENO" 5
+     fi
+@@ -33637,8 +35923,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     OBJC="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OBJC to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting OBJC to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting OBJC to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting OBJC to \"$new_complete\"" >&6;}
+   fi
+ 
+ 
+@@ -33652,12 +35938,13 @@ $as_echo "$as_me: Rewriting OBJC to \"$new_complete\"" >&6;}
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_LIPO+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $LIPO in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_LIPO+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $LIPO in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_LIPO="$LIPO" # Let the user override the test with a path.
+   ;;
+@@ -33666,11 +35953,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_LIPO="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_LIPO="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -33678,15 +35969,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ LIPO=$ac_cv_path_LIPO
+ if test -n "$LIPO"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
+-$as_echo "$LIPO" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
++printf "%s\n" "$LIPO" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -33702,20 +35994,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xLIPO" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LIPO from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of LIPO from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LIPO from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of LIPO from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in lipo
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_LIPO+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $LIPO in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_LIPO+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $LIPO in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_LIPO="$LIPO" # Let the user override the test with a path.
+   ;;
+@@ -33724,11 +36017,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_LIPO="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_LIPO="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -33736,15 +36033,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ LIPO=$ac_cv_path_LIPO
+ if test -n "$LIPO"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
+-$as_echo "$LIPO" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
++printf "%s\n" "$LIPO" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -33764,16 +36062,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LIPO=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool LIPO=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LIPO=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool LIPO=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_LIPO+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $LIPO in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_LIPO+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $LIPO in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_LIPO="$LIPO" # Let the user override the test with a path.
+   ;;
+@@ -33782,11 +36081,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_LIPO="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_LIPO="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -33794,15 +36097,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ LIPO=$ac_cv_path_LIPO
+ if test -n "$LIPO"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
+-$as_echo "$LIPO" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
++printf "%s\n" "$LIPO" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -33811,17 +36115,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LIPO=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool LIPO=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIPO" >&5
+-$as_echo_n "checking for LIPO... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LIPO=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool LIPO=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for LIPO" >&5
++printf %s "checking for LIPO... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool LIPO=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -33868,12 +36172,12 @@ $as_echo "$tool_specified" >&6; }
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
+     fi
+@@ -33895,10 +36199,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of LIPO, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of LIPO, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
+     fi
+   else
+@@ -34008,12 +36312,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
+     fi
+@@ -34085,12 +36389,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
+     fi
+@@ -34105,8 +36409,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     LIPO="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting LIPO to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting LIPO to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting LIPO to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting LIPO to \"$new_complete\"" >&6;}
+   fi
+ 
+   else
+@@ -34116,12 +36420,13 @@ $as_echo "$as_me: Rewriting LIPO to \"$new_complete\"" >&6;}
+   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
+     # Extract the first word of "mt", so it can be a program name with args.
+ set dummy mt; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_MT+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$MT"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_MT+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$MT"; then
+   ac_cv_prog_MT="$MT" # Let the user override the test.
+ else
+   ac_prog_rejected=no
+@@ -34129,15 +36434,19 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/mt"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    if test "$as_dir$ac_word$ac_exec_ext" = "/usr/bin/mt"; then
+        ac_prog_rejected=yes
+        continue
+      fi
+     ac_cv_prog_MT="mt"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -34153,18 +36462,19 @@ if test $ac_prog_rejected = yes; then
+     # However, it has the same basename, so the bogon will be chosen
+     # first if we set MT to just the basename; use the full file name.
+     shift
+-    ac_cv_prog_MT="$as_dir/$ac_word${1+' '}$@"
++    ac_cv_prog_MT="$as_dir$ac_word${1+' '}$@"
+   fi
+ fi
+-fi
++fi ;;
++esac
+ fi
+ MT=$ac_cv_prog_MT
+ if test -n "$MT"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MT" >&5
+-$as_echo "$MT" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MT" >&5
++printf "%s\n" "$MT" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -34209,12 +36519,12 @@ fi
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
+     fi
+@@ -34236,10 +36546,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of MT, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MT, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
+     fi
+   else
+@@ -34349,12 +36659,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
+     fi
+@@ -34426,12 +36736,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
+     fi
+@@ -34446,19 +36756,20 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     MT="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MT to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting MT to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MT to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting MT to \"$new_complete\"" >&6;}
+   fi
+ 
+     # Setup the resource compiler (RC)
+     # Extract the first word of "rc", so it can be a program name with args.
+ set dummy rc; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_RC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$RC"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_RC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$RC"; then
+   ac_cv_prog_RC="$RC" # Let the user override the test.
+ else
+   ac_prog_rejected=no
+@@ -34466,15 +36777,19 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/rc"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    if test "$as_dir$ac_word$ac_exec_ext" = "/usr/bin/rc"; then
+        ac_prog_rejected=yes
+        continue
+      fi
+     ac_cv_prog_RC="rc"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -34490,18 +36805,19 @@ if test $ac_prog_rejected = yes; then
+     # However, it has the same basename, so the bogon will be chosen
+     # first if we set RC to just the basename; use the full file name.
+     shift
+-    ac_cv_prog_RC="$as_dir/$ac_word${1+' '}$@"
++    ac_cv_prog_RC="$as_dir$ac_word${1+' '}$@"
+   fi
+ fi
+-fi
++fi ;;
++esac
+ fi
+ RC=$ac_cv_prog_RC
+ if test -n "$RC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RC" >&5
+-$as_echo "$RC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RC" >&5
++printf "%s\n" "$RC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -34546,12 +36862,12 @@ fi
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
+     fi
+@@ -34573,10 +36889,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of RC, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of RC, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
+     fi
+   else
+@@ -34686,12 +37002,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
+     fi
+@@ -34763,12 +37079,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
+     fi
+@@ -34783,44 +37099,50 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     RC="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting RC to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting RC to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting RC to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting RC to \"$new_complete\"" >&6;}
+   fi
+ 
+     # Extract the first word of "dumpbin", so it can be a program name with args.
+ set dummy dumpbin; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_DUMPBIN+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$DUMPBIN"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_DUMPBIN+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$DUMPBIN"; then
+   ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_DUMPBIN="dumpbin"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ DUMPBIN=$ac_cv_prog_DUMPBIN
+ if test -n "$DUMPBIN"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
+-$as_echo "$DUMPBIN" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
++printf "%s\n" "$DUMPBIN" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -34865,12 +37187,12 @@ fi
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
+     fi
+@@ -34892,10 +37214,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of DUMPBIN, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of DUMPBIN, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
+     fi
+   else
+@@ -35005,12 +37327,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
+     fi
+@@ -35082,12 +37404,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
+     fi
+@@ -35102,8 +37424,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     DUMPBIN="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting DUMPBIN to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting DUMPBIN to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting DUMPBIN to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting DUMPBIN to \"$new_complete\"" >&6;}
+   fi
+ 
+     # We need to check for 'msbuild.exe' because at the place where we expect to
+@@ -35115,38 +37437,44 @@ $as_echo "$as_me: Rewriting DUMPBIN to \"$new_complete\"" >&6;}
+     # 'LIB_SETUP_FREETYPE' in "libraries.m4"
+     # Extract the first word of "msbuild.exe", so it can be a program name with args.
+ set dummy msbuild.exe; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_MSBUILD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$MSBUILD"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_MSBUILD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$MSBUILD"; then
+   ac_cv_prog_MSBUILD="$MSBUILD" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_MSBUILD="msbuild.exe"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ MSBUILD=$ac_cv_prog_MSBUILD
+ if test -n "$MSBUILD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSBUILD" >&5
+-$as_echo "$MSBUILD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSBUILD" >&5
++printf "%s\n" "$MSBUILD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -35164,12 +37492,13 @@ fi
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_STRIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $STRIP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_STRIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $STRIP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
+   ;;
+@@ -35178,11 +37507,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_STRIP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -35190,15 +37523,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ STRIP=$ac_cv_path_STRIP
+ if test -n "$STRIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+-$as_echo "$STRIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
++printf "%s\n" "$STRIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -35214,20 +37548,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xSTRIP" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in strip
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_STRIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $STRIP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_STRIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $STRIP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
+   ;;
+@@ -35236,11 +37571,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_STRIP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -35248,15 +37587,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ STRIP=$ac_cv_path_STRIP
+ if test -n "$STRIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+-$as_echo "$STRIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
++printf "%s\n" "$STRIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -35276,16 +37616,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_STRIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $STRIP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_STRIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $STRIP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
+   ;;
+@@ -35294,11 +37635,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_STRIP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -35306,15 +37651,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ STRIP=$ac_cv_path_STRIP
+ if test -n "$STRIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+-$as_echo "$STRIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
++printf "%s\n" "$STRIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -35323,17 +37669,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
+-$as_echo_n "checking for STRIP... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
++printf %s "checking for STRIP... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool STRIP=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -35380,12 +37726,12 @@ $as_echo "$tool_specified" >&6; }
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
+     fi
+@@ -35407,10 +37753,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of STRIP, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
+     fi
+   else
+@@ -35520,12 +37866,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
+     fi
+@@ -35597,12 +37943,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
+     fi
+@@ -35617,8 +37963,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     STRIP="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
+   fi
+ 
+ 
+@@ -35632,12 +37978,13 @@ $as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_NM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $NM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_NM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $NM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_NM="$NM" # Let the user override the test with a path.
+   ;;
+@@ -35646,11 +37993,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_NM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -35658,15 +38009,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ NM=$ac_cv_path_NM
+ if test -n "$NM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
+-$as_echo "$NM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
++printf "%s\n" "$NM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -35682,20 +38034,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xNM" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in nm
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_NM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $NM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_NM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $NM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_NM="$NM" # Let the user override the test with a path.
+   ;;
+@@ -35704,11 +38057,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_NM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -35716,15 +38073,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ NM=$ac_cv_path_NM
+ if test -n "$NM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
+-$as_echo "$NM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
++printf "%s\n" "$NM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -35744,16 +38102,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_NM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $NM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_NM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $NM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_NM="$NM" # Let the user override the test with a path.
+   ;;
+@@ -35762,11 +38121,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_NM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -35774,15 +38137,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ NM=$ac_cv_path_NM
+ if test -n "$NM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
+-$as_echo "$NM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
++printf "%s\n" "$NM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -35791,17 +38155,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
+-$as_echo_n "checking for NM... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
++printf %s "checking for NM... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool NM=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -35848,12 +38212,12 @@ $as_echo "$tool_specified" >&6; }
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
+     fi
+@@ -35875,10 +38239,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of NM, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of NM, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
+     fi
+   else
+@@ -35988,12 +38352,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
+     fi
+@@ -36065,12 +38429,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
+     fi
+@@ -36085,8 +38449,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     NM="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
+   fi
+ 
+ 
+@@ -36100,12 +38464,13 @@ $as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_GNM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $GNM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_GNM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $GNM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
+   ;;
+@@ -36114,11 +38479,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_GNM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -36126,15 +38495,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ GNM=$ac_cv_path_GNM
+ if test -n "$GNM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
+-$as_echo "$GNM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
++printf "%s\n" "$GNM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -36150,20 +38520,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xGNM" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in gnm
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_GNM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $GNM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_GNM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $GNM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
+   ;;
+@@ -36172,11 +38543,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_GNM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -36184,15 +38559,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ GNM=$ac_cv_path_GNM
+ if test -n "$GNM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
+-$as_echo "$GNM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
++printf "%s\n" "$GNM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -36212,16 +38588,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GNM=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool GNM=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GNM=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool GNM=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_GNM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $GNM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_GNM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $GNM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
+   ;;
+@@ -36230,11 +38607,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_GNM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -36242,15 +38623,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ GNM=$ac_cv_path_GNM
+ if test -n "$GNM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
+-$as_echo "$GNM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
++printf "%s\n" "$GNM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -36259,17 +38641,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GNM=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool GNM=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNM" >&5
+-$as_echo_n "checking for GNM... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GNM=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool GNM=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNM" >&5
++printf %s "checking for GNM... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool GNM=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -36316,12 +38698,12 @@ $as_echo "$tool_specified" >&6; }
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
+     fi
+@@ -36343,10 +38725,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of GNM, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of GNM, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
+     fi
+   else
+@@ -36456,12 +38838,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
+     fi
+@@ -36533,12 +38915,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
+     fi
+@@ -36553,8 +38935,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     GNM="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting GNM to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting GNM to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting GNM to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting GNM to \"$new_complete\"" >&6;}
+   fi
+ 
+ 
+@@ -36569,12 +38951,13 @@ $as_echo "$as_me: Rewriting GNM to \"$new_complete\"" >&6;}
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_MCS+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $MCS in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_MCS+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $MCS in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_MCS="$MCS" # Let the user override the test with a path.
+   ;;
+@@ -36583,11 +38966,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_MCS="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_MCS="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -36595,15 +38982,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ MCS=$ac_cv_path_MCS
+ if test -n "$MCS"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
+-$as_echo "$MCS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
++printf "%s\n" "$MCS" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -36619,20 +39007,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xMCS" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MCS from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of MCS from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MCS from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of MCS from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in mcs
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_MCS+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $MCS in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_MCS+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $MCS in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_MCS="$MCS" # Let the user override the test with a path.
+   ;;
+@@ -36641,11 +39030,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_MCS="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_MCS="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -36653,15 +39046,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ MCS=$ac_cv_path_MCS
+ if test -n "$MCS"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
+-$as_echo "$MCS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
++printf "%s\n" "$MCS" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -36681,16 +39075,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MCS=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool MCS=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MCS=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool MCS=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_MCS+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $MCS in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_MCS+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $MCS in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_MCS="$MCS" # Let the user override the test with a path.
+   ;;
+@@ -36699,11 +39094,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_MCS="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_MCS="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -36711,15 +39110,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ MCS=$ac_cv_path_MCS
+ if test -n "$MCS"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
+-$as_echo "$MCS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
++printf "%s\n" "$MCS" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -36728,17 +39128,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MCS=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool MCS=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MCS" >&5
+-$as_echo_n "checking for MCS... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MCS=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool MCS=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for MCS" >&5
++printf %s "checking for MCS... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool MCS=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -36785,12 +39185,12 @@ $as_echo "$tool_specified" >&6; }
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of MCS" "$LINENO" 5
+     fi
+@@ -36812,10 +39212,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of MCS, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MCS, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of MCS" "$LINENO" 5
+     fi
+   else
+@@ -36925,12 +39325,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of MCS" "$LINENO" 5
+     fi
+@@ -37002,12 +39402,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of MCS" "$LINENO" 5
+     fi
+@@ -37022,8 +39422,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     MCS="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MCS to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting MCS to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MCS to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting MCS to \"$new_complete\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_TARGET_OS" != xwindows; then
+@@ -37040,38 +39440,44 @@ $as_echo "$as_me: Rewriting MCS to \"$new_complete\"" >&6;}
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_STRIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$STRIP"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_STRIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$STRIP"; then
+   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_STRIP="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ STRIP=$ac_cv_prog_STRIP
+ if test -n "$STRIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+-$as_echo "$STRIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
++printf "%s\n" "$STRIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -37084,38 +39490,44 @@ if test -z "$STRIP"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_STRIP"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_STRIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_STRIP"; then
+   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_STRIP="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+ if test -n "$ac_ct_STRIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+-$as_echo "$ac_ct_STRIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
++printf "%s\n" "$ac_ct_STRIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -37127,8 +39539,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     STRIP=$ac_ct_STRIP
+@@ -37144,8 +39556,8 @@ fi
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xSTRIP" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       if test -n "$ac_tool_prefix"; then
+@@ -37153,38 +39565,44 @@ $as_echo "$as_me: WARNING: Ignoring value of STRIP from the environment. Use com
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_STRIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$STRIP"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_STRIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$STRIP"; then
+   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_STRIP="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ STRIP=$ac_cv_prog_STRIP
+ if test -n "$STRIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+-$as_echo "$STRIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
++printf "%s\n" "$STRIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -37197,38 +39615,44 @@ if test -z "$STRIP"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_STRIP"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_STRIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_STRIP"; then
+   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_STRIP="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+ if test -n "$ac_ct_STRIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+-$as_echo "$ac_ct_STRIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
++printf "%s\n" "$ac_ct_STRIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -37240,8 +39664,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     STRIP=$ac_ct_STRIP
+@@ -37261,16 +39685,17 @@ fi
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_STRIP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $STRIP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_STRIP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $STRIP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
+   ;;
+@@ -37279,11 +39704,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_STRIP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -37291,15 +39720,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ STRIP=$ac_cv_path_STRIP
+ if test -n "$STRIP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+-$as_echo "$STRIP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
++printf "%s\n" "$STRIP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -37308,17 +39738,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
+-$as_echo_n "checking for STRIP... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
++printf %s "checking for STRIP... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool STRIP=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -37365,12 +39795,12 @@ $as_echo "$tool_specified" >&6; }
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
+     fi
+@@ -37392,10 +39822,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of STRIP, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
+     fi
+   else
+@@ -37505,12 +39935,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
+     fi
+@@ -37582,12 +40012,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
+     fi
+@@ -37602,18 +40032,19 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     STRIP="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
+   fi
+ 
+     # Extract the first word of "otool", so it can be a program name with args.
+ set dummy otool; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_OTOOL+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $OTOOL in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_OTOOL+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $OTOOL in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
+   ;;
+@@ -37622,11 +40053,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_OTOOL="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -37634,15 +40069,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ OTOOL=$ac_cv_path_OTOOL
+ if test -n "$OTOOL"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
+-$as_echo "$OTOOL" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
++printf "%s\n" "$OTOOL" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -37661,38 +40097,44 @@ fi
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_NM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$NM"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_NM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$NM"; then
+   ac_cv_prog_NM="$NM" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ NM=$ac_cv_prog_NM
+ if test -n "$NM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
+-$as_echo "$NM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
++printf "%s\n" "$NM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -37705,38 +40147,44 @@ if test -z "$NM"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_NM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_NM"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_NM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_NM"; then
+   ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_NM="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_NM=$ac_cv_prog_ac_ct_NM
+ if test -n "$ac_ct_NM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
+-$as_echo "$ac_ct_NM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
++printf "%s\n" "$ac_ct_NM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -37748,8 +40196,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     NM=$ac_ct_NM
+@@ -37765,8 +40213,8 @@ fi
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xNM" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       if test -n "$ac_tool_prefix"; then
+@@ -37774,38 +40222,44 @@ $as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use comman
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_NM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$NM"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_NM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$NM"; then
+   ac_cv_prog_NM="$NM" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ NM=$ac_cv_prog_NM
+ if test -n "$NM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
+-$as_echo "$NM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
++printf "%s\n" "$NM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -37818,38 +40272,44 @@ if test -z "$NM"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_NM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_NM"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_NM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_NM"; then
+   ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_NM="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_NM=$ac_cv_prog_ac_ct_NM
+ if test -n "$ac_ct_NM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
+-$as_echo "$ac_ct_NM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
++printf "%s\n" "$ac_ct_NM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -37861,8 +40321,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     NM=$ac_ct_NM
+@@ -37882,16 +40342,17 @@ fi
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_NM+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $NM in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_NM+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $NM in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_NM="$NM" # Let the user override the test with a path.
+   ;;
+@@ -37900,11 +40361,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_NM="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -37912,15 +40377,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ NM=$ac_cv_path_NM
+ if test -n "$NM"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
+-$as_echo "$NM" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
++printf "%s\n" "$NM" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -37929,17 +40395,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
+-$as_echo_n "checking for NM... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
++printf %s "checking for NM... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool NM=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -37986,12 +40452,12 @@ $as_echo "$tool_specified" >&6; }
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
+     fi
+@@ -38013,10 +40479,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of NM, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of NM, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
+     fi
+   else
+@@ -38126,12 +40592,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
+     fi
+@@ -38203,12 +40669,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
+     fi
+@@ -38223,8 +40689,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     NM="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
+   fi
+ 
+     GNM="$NM"
+@@ -38246,38 +40712,44 @@ $as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_OBJCOPY+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$OBJCOPY"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_OBJCOPY+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$OBJCOPY"; then
+   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_OBJCOPY="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ OBJCOPY=$ac_cv_prog_OBJCOPY
+ if test -n "$OBJCOPY"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
+-$as_echo "$OBJCOPY" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
++printf "%s\n" "$OBJCOPY" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -38290,38 +40762,44 @@ if test -z "$OBJCOPY"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_OBJCOPY+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_OBJCOPY"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_OBJCOPY+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_OBJCOPY"; then
+   ac_cv_prog_ac_ct_OBJCOPY="$ac_ct_OBJCOPY" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_OBJCOPY="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_OBJCOPY=$ac_cv_prog_ac_ct_OBJCOPY
+ if test -n "$ac_ct_OBJCOPY"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJCOPY" >&5
+-$as_echo "$ac_ct_OBJCOPY" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJCOPY" >&5
++printf "%s\n" "$ac_ct_OBJCOPY" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -38333,8 +40811,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     OBJCOPY=$ac_ct_OBJCOPY
+@@ -38350,8 +40828,8 @@ fi
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xOBJCOPY" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       if test -n "$ac_tool_prefix"; then
+@@ -38359,38 +40837,44 @@ $as_echo "$as_me: WARNING: Ignoring value of OBJCOPY from the environment. Use c
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_OBJCOPY+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$OBJCOPY"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_OBJCOPY+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$OBJCOPY"; then
+   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_OBJCOPY="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ OBJCOPY=$ac_cv_prog_OBJCOPY
+ if test -n "$OBJCOPY"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
+-$as_echo "$OBJCOPY" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
++printf "%s\n" "$OBJCOPY" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -38403,38 +40887,44 @@ if test -z "$OBJCOPY"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_OBJCOPY+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_OBJCOPY"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_OBJCOPY+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_OBJCOPY"; then
+   ac_cv_prog_ac_ct_OBJCOPY="$ac_ct_OBJCOPY" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_OBJCOPY="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_OBJCOPY=$ac_cv_prog_ac_ct_OBJCOPY
+ if test -n "$ac_ct_OBJCOPY"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJCOPY" >&5
+-$as_echo "$ac_ct_OBJCOPY" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJCOPY" >&5
++printf "%s\n" "$ac_ct_OBJCOPY" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -38446,8 +40936,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     OBJCOPY=$ac_ct_OBJCOPY
+@@ -38467,16 +40957,17 @@ fi
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJCOPY=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool OBJCOPY=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJCOPY=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool OBJCOPY=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_OBJCOPY+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $OBJCOPY in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_OBJCOPY+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $OBJCOPY in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_OBJCOPY="$OBJCOPY" # Let the user override the test with a path.
+   ;;
+@@ -38485,11 +40976,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_OBJCOPY="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_OBJCOPY="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -38497,15 +40992,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ OBJCOPY=$ac_cv_path_OBJCOPY
+ if test -n "$OBJCOPY"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
+-$as_echo "$OBJCOPY" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
++printf "%s\n" "$OBJCOPY" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -38514,17 +41010,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJCOPY=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool OBJCOPY=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJCOPY" >&5
+-$as_echo_n "checking for OBJCOPY... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJCOPY=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool OBJCOPY=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for OBJCOPY" >&5
++printf %s "checking for OBJCOPY... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool OBJCOPY=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -38573,12 +41069,12 @@ $as_echo "$tool_specified" >&6; }
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
+     fi
+@@ -38600,10 +41096,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of OBJCOPY, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of OBJCOPY, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
+     fi
+   else
+@@ -38713,12 +41209,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
+     fi
+@@ -38790,12 +41286,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
+     fi
+@@ -38810,8 +41306,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     OBJCOPY="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OBJCOPY to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting OBJCOPY to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting OBJCOPY to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting OBJCOPY to \"$new_complete\"" >&6;}
+   fi
+ 
+     fi
+@@ -38829,38 +41325,44 @@ $as_echo "$as_me: Rewriting OBJCOPY to \"$new_complete\"" >&6;}
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_OBJDUMP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$OBJDUMP"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_OBJDUMP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$OBJDUMP"; then
+   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_OBJDUMP="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ OBJDUMP=$ac_cv_prog_OBJDUMP
+ if test -n "$OBJDUMP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+-$as_echo "$OBJDUMP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
++printf "%s\n" "$OBJDUMP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -38873,38 +41375,44 @@ if test -z "$OBJDUMP"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_OBJDUMP"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_OBJDUMP"; then
+   ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_OBJDUMP="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
+ if test -n "$ac_ct_OBJDUMP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+-$as_echo "$ac_ct_OBJDUMP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
++printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -38916,8 +41424,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     OBJDUMP=$ac_ct_OBJDUMP
+@@ -38933,8 +41441,8 @@ fi
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xOBJDUMP" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       if test -n "$ac_tool_prefix"; then
+@@ -38942,38 +41450,44 @@ $as_echo "$as_me: WARNING: Ignoring value of OBJDUMP from the environment. Use c
+   do
+     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+ set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_OBJDUMP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$OBJDUMP"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_OBJDUMP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$OBJDUMP"; then
+   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_OBJDUMP="$ac_tool_prefix$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ OBJDUMP=$ac_cv_prog_OBJDUMP
+ if test -n "$OBJDUMP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+-$as_echo "$OBJDUMP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
++printf "%s\n" "$OBJDUMP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -38986,38 +41500,44 @@ if test -z "$OBJDUMP"; then
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$ac_ct_OBJDUMP"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$ac_ct_OBJDUMP"; then
+   ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_ac_ct_OBJDUMP="$ac_prog"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
+ if test -n "$ac_ct_OBJDUMP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+-$as_echo "$ac_ct_OBJDUMP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
++printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -39029,8 +41549,8 @@ done
+   else
+     case $cross_compiling:$ac_tool_warned in
+ yes:)
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+-$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
++printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ ac_tool_warned=yes ;;
+ esac
+     OBJDUMP=$ac_ct_OBJDUMP
+@@ -39050,16 +41570,17 @@ fi
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJDUMP=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool OBJDUMP=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJDUMP=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool OBJDUMP=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_OBJDUMP+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $OBJDUMP in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_OBJDUMP+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $OBJDUMP in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_OBJDUMP="$OBJDUMP" # Let the user override the test with a path.
+   ;;
+@@ -39068,11 +41589,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_OBJDUMP="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_OBJDUMP="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -39080,15 +41605,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ OBJDUMP=$ac_cv_path_OBJDUMP
+ if test -n "$OBJDUMP"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+-$as_echo "$OBJDUMP" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
++printf "%s\n" "$OBJDUMP" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -39097,17 +41623,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJDUMP=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool OBJDUMP=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJDUMP" >&5
+-$as_echo_n "checking for OBJDUMP... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJDUMP=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool OBJDUMP=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for OBJDUMP" >&5
++printf %s "checking for OBJDUMP... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool OBJDUMP=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -39157,12 +41683,12 @@ $as_echo "$tool_specified" >&6; }
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
+     fi
+@@ -39184,10 +41710,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of OBJDUMP, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of OBJDUMP, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
+     fi
+   else
+@@ -39297,12 +41823,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
+     fi
+@@ -39374,12 +41900,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
+     fi
+@@ -39394,8 +41920,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     OBJDUMP="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OBJDUMP to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting OBJDUMP to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting OBJDUMP to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting OBJDUMP to \"$new_complete\"" >&6;}
+   fi
+ 
+   fi
+@@ -39439,12 +41965,13 @@ $as_echo "$as_me: Rewriting OBJDUMP to \"$new_complete\"" >&6;}
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_CC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_CC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_CC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_CC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
+   ;;
+@@ -39453,11 +41980,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_CC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -39465,15 +41996,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_CC=$ac_cv_path_BUILD_CC
+ if test -n "$BUILD_CC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
+-$as_echo "$BUILD_CC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
++printf "%s\n" "$BUILD_CC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -39489,20 +42021,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xBUILD_CC" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in clang cl cc gcc
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_CC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_CC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_CC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_CC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
+   ;;
+@@ -39511,11 +42044,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_CC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -39523,15 +42060,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_CC=$ac_cv_path_BUILD_CC
+ if test -n "$BUILD_CC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
+-$as_echo "$BUILD_CC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
++printf "%s\n" "$BUILD_CC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -39551,16 +42089,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CC=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool BUILD_CC=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CC=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool BUILD_CC=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_CC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_CC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_CC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_CC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
+   ;;
+@@ -39569,11 +42108,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_CC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -39581,15 +42124,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_CC=$ac_cv_path_BUILD_CC
+ if test -n "$BUILD_CC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
+-$as_echo "$BUILD_CC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
++printf "%s\n" "$BUILD_CC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -39598,17 +42142,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CC=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool BUILD_CC=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CC" >&5
+-$as_echo_n "checking for BUILD_CC... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CC=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool BUILD_CC=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BUILD_CC" >&5
++printf %s "checking for BUILD_CC... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool BUILD_CC=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -39625,12 +42169,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_CXX+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_CXX in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_CXX+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_CXX in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
+   ;;
+@@ -39639,11 +42184,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_CXX="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -39651,15 +42200,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_CXX=$ac_cv_path_BUILD_CXX
+ if test -n "$BUILD_CXX"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
+-$as_echo "$BUILD_CXX" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
++printf "%s\n" "$BUILD_CXX" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -39675,20 +42225,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xBUILD_CXX" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in clang++ cl CC g++
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_CXX+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_CXX in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_CXX+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_CXX in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
+   ;;
+@@ -39697,11 +42248,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_CXX="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -39709,15 +42264,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_CXX=$ac_cv_path_BUILD_CXX
+ if test -n "$BUILD_CXX"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
+-$as_echo "$BUILD_CXX" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
++printf "%s\n" "$BUILD_CXX" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -39737,16 +42293,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CXX=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool BUILD_CXX=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CXX=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool BUILD_CXX=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_CXX+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_CXX in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_CXX+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_CXX in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
+   ;;
+@@ -39755,11 +42312,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_CXX="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -39767,15 +42328,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_CXX=$ac_cv_path_BUILD_CXX
+ if test -n "$BUILD_CXX"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
+-$as_echo "$BUILD_CXX" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
++printf "%s\n" "$BUILD_CXX" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -39784,17 +42346,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CXX=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool BUILD_CXX=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CXX" >&5
+-$as_echo_n "checking for BUILD_CXX... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CXX=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool BUILD_CXX=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BUILD_CXX" >&5
++printf %s "checking for BUILD_CXX... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool BUILD_CXX=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -39813,12 +42375,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_CC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_CC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_CC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_CC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
+   ;;
+@@ -39827,11 +42390,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_CC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -39839,15 +42406,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_CC=$ac_cv_path_BUILD_CC
+ if test -n "$BUILD_CC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
+-$as_echo "$BUILD_CC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
++printf "%s\n" "$BUILD_CC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -39863,20 +42431,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xBUILD_CC" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in cl cc gcc
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_CC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_CC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_CC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_CC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
+   ;;
+@@ -39885,11 +42454,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_CC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -39897,15 +42470,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_CC=$ac_cv_path_BUILD_CC
+ if test -n "$BUILD_CC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
+-$as_echo "$BUILD_CC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
++printf "%s\n" "$BUILD_CC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -39925,16 +42499,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CC=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool BUILD_CC=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CC=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool BUILD_CC=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_CC+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_CC in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_CC+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_CC in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
+   ;;
+@@ -39943,11 +42518,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_CC="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -39955,15 +42534,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_CC=$ac_cv_path_BUILD_CC
+ if test -n "$BUILD_CC"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
+-$as_echo "$BUILD_CC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
++printf "%s\n" "$BUILD_CC" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -39972,17 +42552,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CC=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool BUILD_CC=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CC" >&5
+-$as_echo_n "checking for BUILD_CC... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CC=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool BUILD_CC=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BUILD_CC" >&5
++printf %s "checking for BUILD_CC... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool BUILD_CC=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -40006,12 +42586,13 @@ $as_echo "$tool_specified" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_CXX+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_CXX in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_CXX+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_CXX in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
+   ;;
+@@ -40020,11 +42601,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_CXX="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -40032,15 +42617,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_CXX=$ac_cv_path_BUILD_CXX
+ if test -n "$BUILD_CXX"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
+-$as_echo "$BUILD_CXX" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
++printf "%s\n" "$BUILD_CXX" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -40056,20 +42642,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xBUILD_CXX" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in cl CC g++
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_CXX+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_CXX in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_CXX+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_CXX in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
+   ;;
+@@ -40078,11 +42665,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_CXX="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -40090,15 +42681,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_CXX=$ac_cv_path_BUILD_CXX
+ if test -n "$BUILD_CXX"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
+-$as_echo "$BUILD_CXX" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
++printf "%s\n" "$BUILD_CXX" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -40118,16 +42710,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CXX=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool BUILD_CXX=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CXX=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool BUILD_CXX=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_CXX+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_CXX in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_CXX+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_CXX in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
+   ;;
+@@ -40136,11 +42729,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_CXX="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -40148,15 +42745,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_CXX=$ac_cv_path_BUILD_CXX
+ if test -n "$BUILD_CXX"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
+-$as_echo "$BUILD_CXX" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
++printf "%s\n" "$BUILD_CXX" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -40165,17 +42763,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CXX=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool BUILD_CXX=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CXX" >&5
+-$as_echo_n "checking for BUILD_CXX... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CXX=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool BUILD_CXX=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BUILD_CXX" >&5
++printf %s "checking for BUILD_CXX... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool BUILD_CXX=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -40229,12 +42827,12 @@ $as_echo "$tool_specified" >&6; }
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
+     fi
+@@ -40256,10 +42854,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of BUILD_CC, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BUILD_CC, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
+     fi
+   else
+@@ -40369,12 +42967,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
+     fi
+@@ -40446,12 +43044,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
+     fi
+@@ -40466,8 +43064,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     BUILD_CC="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CC to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting BUILD_CC to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CC to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting BUILD_CC to \"$new_complete\"" >&6;}
+   fi
+ 
+ 
+@@ -40511,12 +43109,12 @@ $as_echo "$as_me: Rewriting BUILD_CC to \"$new_complete\"" >&6;}
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
+     fi
+@@ -40538,10 +43136,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BUILD_CXX, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
+     fi
+   else
+@@ -40651,12 +43249,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
+     fi
+@@ -40728,12 +43326,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
+     fi
+@@ -40748,8 +43346,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     BUILD_CXX="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CXX to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting BUILD_CXX to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CXX to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting BUILD_CXX to \"$new_complete\"" >&6;}
+   fi
+ 
+ 
+@@ -40763,12 +43361,13 @@ $as_echo "$as_me: Rewriting BUILD_CXX to \"$new_complete\"" >&6;}
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_LD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_LD in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_LD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_LD in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_LD="$BUILD_LD" # Let the user override the test with a path.
+   ;;
+@@ -40777,11 +43376,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_LD="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_LD="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -40789,15 +43392,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_LD=$ac_cv_path_BUILD_LD
+ if test -n "$BUILD_LD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
+-$as_echo "$BUILD_LD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
++printf "%s\n" "$BUILD_LD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -40813,20 +43417,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xBUILD_LD" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_LD from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of BUILD_LD from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_LD from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of BUILD_LD from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in ld
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_LD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_LD in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_LD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_LD in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_LD="$BUILD_LD" # Let the user override the test with a path.
+   ;;
+@@ -40835,11 +43440,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_LD="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_LD="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -40847,15 +43456,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_LD=$ac_cv_path_BUILD_LD
+ if test -n "$BUILD_LD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
+-$as_echo "$BUILD_LD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
++printf "%s\n" "$BUILD_LD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -40875,16 +43485,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_LD=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool BUILD_LD=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_LD=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool BUILD_LD=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_BUILD_LD+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $BUILD_LD in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_BUILD_LD+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $BUILD_LD in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_BUILD_LD="$BUILD_LD" # Let the user override the test with a path.
+   ;;
+@@ -40893,11 +43504,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_BUILD_LD="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_BUILD_LD="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -40905,15 +43520,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ BUILD_LD=$ac_cv_path_BUILD_LD
+ if test -n "$BUILD_LD"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
+-$as_echo "$BUILD_LD" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
++printf "%s\n" "$BUILD_LD" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -40922,17 +43538,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_LD=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool BUILD_LD=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_LD" >&5
+-$as_echo_n "checking for BUILD_LD... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_LD=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool BUILD_LD=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BUILD_LD" >&5
++printf %s "checking for BUILD_LD... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool BUILD_LD=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -40979,12 +43595,12 @@ $as_echo "$tool_specified" >&6; }
+     fi
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of BUILD_LD" "$LINENO" 5
+     fi
+@@ -41006,10 +43622,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     elif test -f "${new_path}.cmd"; then
+       input_to_shortpath="${new_path}.cmd"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$new_path\", is invalid." >&5
+-$as_echo "$as_me: The path of BUILD_LD, which resolves as \"$new_path\", is invalid." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
+-$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$new_path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of BUILD_LD, which resolves as \"$new_path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
++printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
+       as_fn_error $? "Cannot locate the the path of BUILD_LD" "$LINENO" 5
+     fi
+   else
+@@ -41119,12 +43735,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
+ 
+     if test "x$new_path" = x; then
+       # It's still not found. Now this is an unrecoverable error.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
+-$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
++printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of BUILD_LD" "$LINENO" 5
+     fi
+@@ -41196,12 +43812,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
+     fi
+ 
+     if test "x$new_path" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
+-$as_echo "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
++printf "%s\n" "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
+       has_space=`$ECHO "$complete" | $GREP " "`
+       if test "x$has_space" != x; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
+-$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
++printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
+       fi
+       as_fn_error $? "Cannot locate the the path of BUILD_LD" "$LINENO" 5
+     fi
+@@ -41216,8 +43832,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
+ 
+   if test "x$complete" != "x$new_complete"; then
+     BUILD_LD="$new_complete"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_LD to \"$new_complete\"" >&5
+-$as_echo "$as_me: Rewriting BUILD_LD to \"$new_complete\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_LD to \"$new_complete\"" >&5
++printf "%s\n" "$as_me: Rewriting BUILD_LD to \"$new_complete\"" >&6;}
+   fi
+ 
+   else
+@@ -41327,11 +43943,11 @@ $as_echo "$as_me: Rewriting BUILD_LD to \"$new_complete\"" >&6;}
+ 
+   if test "x$TOOLCHAIN_TYPE" = xgcc; then
+     if test "x$OPENJDK_TARGET_CPU_ARCH" = "xaarch64" ; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for broken aarch64 gcc 4.x" >&5
+-$as_echo_n "checking for broken aarch64 gcc 4.x... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for broken aarch64 gcc 4.x" >&5
++printf %s "checking for broken aarch64 gcc 4.x... " >&6; }
+       COMPILER_VERSION_NUMBER_MAJOR=`$ECHO "$COMPILER_VERSION_NUMBER" | $SED  "s/[^0-9].*//"`
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: found $COMPILER_VERSION_NUMBER_MAJOR.x" >&5
+-$as_echo "found $COMPILER_VERSION_NUMBER_MAJOR.x" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: found $COMPILER_VERSION_NUMBER_MAJOR.x" >&5
++printf "%s\n" "found $COMPILER_VERSION_NUMBER_MAJOR.x" >&6; }
+       if test $COMPILER_VERSION_NUMBER_MAJOR -lt 5; then
+         as_fn_error $? "GCC < 5 may incorrectly compile HotSpot on aarch64. See JDK-8360869." "$LINENO" 5
+       fi
+@@ -41342,17 +43958,17 @@ $as_echo "found $COMPILER_VERSION_NUMBER_MAJOR.x" >&6; }
+   # in executable.'
+   USING_BROKEN_SUSE_LD=no
+   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$TOOLCHAIN_TYPE" = xgcc; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for broken SuSE 'ld' which only understands anonymous version tags in executables" >&5
+-$as_echo_n "checking for broken SuSE 'ld' which only understands anonymous version tags in executables... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for broken SuSE 'ld' which only understands anonymous version tags in executables" >&5
++printf %s "checking for broken SuSE 'ld' which only understands anonymous version tags in executables... " >&6; }
+     echo "SUNWprivate_1.1 { local: *; };" > version-script.map
+     echo "int main() { }" > main.c
+     if $CXX -Xlinker -version-script=version-script.map main.c 2>&5 >&5; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+       USING_BROKEN_SUSE_LD=no
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+       USING_BROKEN_SUSE_LD=yes
+     fi
+     rm -rf version-script.map main.c
+@@ -41364,19 +43980,21 @@ $as_echo "yes" >&6; }
+ 
+ 
+ # Check whether --with-jtreg was given.
+-if test "${with_jtreg+set}" = set; then :
++if test ${with_jtreg+y}
++then :
+   withval=$with_jtreg;
+-else
+-  with_jtreg=no
++else case e in #(
++  e) with_jtreg=no ;;
++esac
+ fi
+ 
+ 
+   if test "x$with_jtreg" = xno; then
+     # jtreg disabled
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jtreg" >&5
+-$as_echo_n "checking for jtreg... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for jtreg" >&5
++printf %s "checking for jtreg... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+   else
+     if test "x$with_jtreg" != xyes; then
+       # with path specified.
+@@ -41384,8 +44002,8 @@ $as_echo "no" >&6; }
+     fi
+ 
+     if test "x$JT_HOME" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jtreg" >&5
+-$as_echo_n "checking for jtreg... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for jtreg" >&5
++printf %s "checking for jtreg... " >&6; }
+ 
+       # use JT_HOME enviroment var.
+ 
+@@ -41408,8 +44026,8 @@ $as_echo_n "checking for jtreg... " >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of JT_HOME" "$LINENO" 5
+   fi
+ 
+@@ -41457,8 +44075,8 @@ $as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid."
+ 
+   if test "x$path" != "x$new_path"; then
+     JT_HOME="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -41495,8 +44113,8 @@ $as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     JT_HOME="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -41507,8 +44125,8 @@ $as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
+     path="$JT_HOME"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -41529,8 +44147,8 @@ $as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid."
+         as_fn_error $? "JTReg executable does not exist: $JTREGEXE" "$LINENO" 5
+       fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
+-$as_echo "$JTREGEXE" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
++printf "%s\n" "$JTREGEXE" >&6; }
+     else
+       # try to find jtreg on path
+ 
+@@ -41545,12 +44163,13 @@ $as_echo "$JTREGEXE" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_JTREGEXE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $JTREGEXE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_JTREGEXE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $JTREGEXE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
+   ;;
+@@ -41559,11 +44178,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_JTREGEXE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -41571,15 +44194,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ JTREGEXE=$ac_cv_path_JTREGEXE
+ if test -n "$JTREGEXE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
+-$as_echo "$JTREGEXE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
++printf "%s\n" "$JTREGEXE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -41595,20 +44219,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xJTREGEXE" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in jtreg
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_JTREGEXE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $JTREGEXE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_JTREGEXE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $JTREGEXE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
+   ;;
+@@ -41617,11 +44242,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_JTREGEXE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -41629,15 +44258,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ JTREGEXE=$ac_cv_path_JTREGEXE
+ if test -n "$JTREGEXE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
+-$as_echo "$JTREGEXE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
++printf "%s\n" "$JTREGEXE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -41657,16 +44287,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JTREGEXE=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool JTREGEXE=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JTREGEXE=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool JTREGEXE=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_JTREGEXE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $JTREGEXE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_JTREGEXE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $JTREGEXE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
+   ;;
+@@ -41675,11 +44306,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_JTREGEXE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -41687,15 +44322,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ JTREGEXE=$ac_cv_path_JTREGEXE
+ if test -n "$JTREGEXE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
+-$as_echo "$JTREGEXE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
++printf "%s\n" "$JTREGEXE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -41704,17 +44340,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JTREGEXE=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool JTREGEXE=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JTREGEXE" >&5
+-$as_echo_n "checking for JTREGEXE... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JTREGEXE=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool JTREGEXE=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for JTREGEXE" >&5
++printf %s "checking for JTREGEXE... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool JTREGEXE=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -41864,137 +44500,36 @@ $as_echo "$tool_specified" >&6; }
+ 
+ # Now we can test some aspects on the target using configure macros.
+ 
++ac_header= ac_cache=
++for ac_item in $ac_header_cxx_list
++do
++  if test $ac_cache; then
++    ac_fn_cxx_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default"
++    if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then
++      printf "%s\n" "#define $ac_item 1" >> confdefs.h
++    fi
++    ac_header= ac_cache=
++  elif test $ac_header; then
++    ac_cache=$ac_item
++  else
++    ac_header=$ac_item
++  fi
++done
+ 
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
+-$as_echo_n "checking for ANSI C header files... " >&6; }
+-if ${ac_cv_header_stdc+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+-/* end confdefs.h.  */
+-#include <stdlib.h>
+-#include <stdarg.h>
+-#include <string.h>
+-#include <float.h>
+-
+-int
+-main ()
+-{
+-
+-  ;
+-  return 0;
+-}
+-_ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
+-  ac_cv_header_stdc=yes
+-else
+-  ac_cv_header_stdc=no
+-fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+-
+-if test $ac_cv_header_stdc = yes; then
+-  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+-/* end confdefs.h.  */
+-#include <string.h>
+-
+-_ACEOF
+-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+-  $EGREP "memchr" >/dev/null 2>&1; then :
+-
+-else
+-  ac_cv_header_stdc=no
+-fi
+-rm -f conftest*
+-
+-fi
+-
+-if test $ac_cv_header_stdc = yes; then
+-  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
+-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+-/* end confdefs.h.  */
+-#include <stdlib.h>
+-
+-_ACEOF
+-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+-  $EGREP "free" >/dev/null 2>&1; then :
+-
+-else
+-  ac_cv_header_stdc=no
+-fi
+-rm -f conftest*
+ 
+-fi
+ 
+-if test $ac_cv_header_stdc = yes; then
+-  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+-  if test "$cross_compiling" = yes; then :
+-  :
+-else
+-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+-/* end confdefs.h.  */
+-#include <ctype.h>
+-#include <stdlib.h>
+-#if ((' ' & 0x0FF) == 0x020)
+-# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+-# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+-#else
+-# define ISLOWER(c) \
+-		   (('a' <= (c) && (c) <= 'i') \
+-		     || ('j' <= (c) && (c) <= 'r') \
+-		     || ('s' <= (c) && (c) <= 'z'))
+-# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+-#endif
+ 
+-#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+-int
+-main ()
+-{
+-  int i;
+-  for (i = 0; i < 256; i++)
+-    if (XOR (islower (i), ISLOWER (i))
+-	|| toupper (i) != TOUPPER (i))
+-      return 2;
+-  return 0;
+-}
+-_ACEOF
+-if ac_fn_cxx_try_run "$LINENO"; then :
+ 
+-else
+-  ac_cv_header_stdc=no
+-fi
+-rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+-  conftest.$ac_objext conftest.beam conftest.$ac_ext
+-fi
+ 
+-fi
+-fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
+-$as_echo "$ac_cv_header_stdc" >&6; }
+-if test $ac_cv_header_stdc = yes; then
+ 
+-$as_echo "#define STDC_HEADERS 1" >>confdefs.h
+ 
+-fi
++if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes
++then :
+ 
+-# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+-for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+-		  inttypes.h stdint.h unistd.h
+-do :
+-  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-ac_fn_cxx_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
+-"
+-if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
+-  cat >>confdefs.h <<_ACEOF
+-#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
+-_ACEOF
++printf "%s\n" "#define STDC_HEADERS 1" >>confdefs.h
+ 
+ fi
+ 
+-done
+-
+-
+-
+   ###############################################################################
+   #
+   # Now we check if libjvm.so will use 32 or 64 bit pointers for the C/C++ code.
+@@ -42046,81 +44581,82 @@ done
+   fi
+ 
+   # Make compilation sanity check
+-  for ac_header in stdio.h
++         for ac_header in stdio.h
+ do :
+-  ac_fn_cxx_check_header_mongrel "$LINENO" "stdio.h" "ac_cv_header_stdio_h" "$ac_includes_default"
+-if test "x$ac_cv_header_stdio_h" = xyes; then :
+-  cat >>confdefs.h <<_ACEOF
+-#define HAVE_STDIO_H 1
+-_ACEOF
+-
+-else
+-
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Failed to compile stdio.h. This likely implies missing compile dependencies." >&5
+-$as_echo "$as_me: Failed to compile stdio.h. This likely implies missing compile dependencies." >&6;}
++  ac_fn_cxx_check_header_compile "$LINENO" "stdio.h" "ac_cv_header_stdio_h" "$ac_includes_default"
++if test "x$ac_cv_header_stdio_h" = xyes
++then :
++  printf "%s\n" "#define HAVE_STDIO_H 1" >>confdefs.h
++
++else case e in #(
++  e)
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Failed to compile stdio.h. This likely implies missing compile dependencies." >&5
++printf "%s\n" "$as_me: Failed to compile stdio.h. This likely implies missing compile dependencies." >&6;}
+     if test "x$COMPILE_TYPE" = xreduced; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: You are doing a reduced build. Check that you have 32-bit libraries installed." >&5
+-$as_echo "$as_me: You are doing a reduced build. Check that you have 32-bit libraries installed." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You are doing a reduced build. Check that you have 32-bit libraries installed." >&5
++printf "%s\n" "$as_me: You are doing a reduced build. Check that you have 32-bit libraries installed." >&6;}
+     elif test "x$COMPILE_TYPE" = xcross; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&5
+-$as_echo "$as_me: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&5
++printf "%s\n" "$as_me: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&6;}
+     fi
+     as_fn_error $? "Cannot continue." "$LINENO" 5
+-
++   ;;
++esac
+ fi
+ 
+ done
+ 
+-
+   # The cast to long int works around a bug in the HP C Compiler
+ # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
+-# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
++# declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'.
+ # This bug is HP SR number 8606223364.
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5
+-$as_echo_n "checking size of int *... " >&6; }
+-if ${ac_cv_sizeof_int_p+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p"        "$ac_includes_default"; then :
+-
+-else
+-  if test "$ac_cv_type_int_p" = yes; then
+-     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5
++printf %s "checking size of int *... " >&6; }
++if test ${ac_cv_sizeof_int_p+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p"        "$ac_includes_default"
++then :
++
++else case e in #(
++  e) if test "$ac_cv_type_int_p" = yes; then
++     { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
++printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ as_fn_error 77 "cannot compute sizeof (int *)
+-See \`config.log' for more details" "$LINENO" 5; }
++See 'config.log' for more details" "$LINENO" 5; }
+    else
+      ac_cv_sizeof_int_p=0
+-   fi
++   fi ;;
++esac
+ fi
+-
++ ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5
+-$as_echo "$ac_cv_sizeof_int_p" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5
++printf "%s\n" "$ac_cv_sizeof_int_p" >&6; }
+ 
+ 
+ 
+-cat >>confdefs.h <<_ACEOF
+-#define SIZEOF_INT_P $ac_cv_sizeof_int_p
+-_ACEOF
++printf "%s\n" "#define SIZEOF_INT_P $ac_cv_sizeof_int_p" >>confdefs.h
+ 
+ 
+ 
+   # AC_CHECK_SIZEOF defines 'ac_cv_sizeof_int_p' to hold the number of bytes used by an 'int*'
+   if test "x$ac_cv_sizeof_int_p" = x; then
+     # The test failed, lets stick to the assumed value.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The number of bits in the target could not be determined, using $OPENJDK_TARGET_CPU_BITS." >&5
+-$as_echo "$as_me: WARNING: The number of bits in the target could not be determined, using $OPENJDK_TARGET_CPU_BITS." >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: The number of bits in the target could not be determined, using $OPENJDK_TARGET_CPU_BITS." >&5
++printf "%s\n" "$as_me: WARNING: The number of bits in the target could not be determined, using $OPENJDK_TARGET_CPU_BITS." >&2;}
+   else
+     TESTED_TARGET_CPU_BITS=`expr 8 \* $ac_cv_sizeof_int_p`
+ 
+     if test "x$TESTED_TARGET_CPU_BITS" != "x$OPENJDK_TARGET_CPU_BITS"; then
+       # This situation may happen on 64-bit platforms where the compiler by default only generates 32-bit objects
+       # Let's try to implicitely set the compilers target architecture and retry the test
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)." >&5
+-$as_echo "$as_me: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)." >&6;}
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: I'll retry after setting the platforms compiler target bits flag to ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" >&5
+-$as_echo "$as_me: I'll retry after setting the platforms compiler target bits flag to ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)." >&5
++printf "%s\n" "$as_me: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: I'll retry after setting the platforms compiler target bits flag to ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" >&5
++printf "%s\n" "$as_me: I'll retry after setting the platforms compiler target bits flag to ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" >&6;}
+ 
+   # When we add flags to the "official" CFLAGS etc, we need to
+   # keep track of these additions in ADDED_CFLAGS etc. These
+@@ -42148,35 +44684,37 @@ _ACEOF
+ 
+       # The cast to long int works around a bug in the HP C Compiler
+ # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
+-# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
++# declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'.
+ # This bug is HP SR number 8606223364.
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5
+-$as_echo_n "checking size of int *... " >&6; }
+-if ${ac_cv_sizeof_int_p+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p"        "$ac_includes_default"; then :
+-
+-else
+-  if test "$ac_cv_type_int_p" = yes; then
+-     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5
++printf %s "checking size of int *... " >&6; }
++if test ${ac_cv_sizeof_int_p+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p"        "$ac_includes_default"
++then :
++
++else case e in #(
++  e) if test "$ac_cv_type_int_p" = yes; then
++     { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
++printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ as_fn_error 77 "cannot compute sizeof (int *)
+-See \`config.log' for more details" "$LINENO" 5; }
++See 'config.log' for more details" "$LINENO" 5; }
+    else
+      ac_cv_sizeof_int_p=0
+-   fi
++   fi ;;
++esac
+ fi
+-
++ ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5
+-$as_echo "$ac_cv_sizeof_int_p" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5
++printf "%s\n" "$ac_cv_sizeof_int_p" >&6; }
+ 
+ 
+ 
+-cat >>confdefs.h <<_ACEOF
+-#define SIZEOF_INT_P $ac_cv_sizeof_int_p
+-_ACEOF
++printf "%s\n" "#define SIZEOF_INT_P $ac_cv_sizeof_int_p" >>confdefs.h
+ 
+ 
+ 
+@@ -42188,22 +44726,23 @@ _ACEOF
+     fi
+   fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for target address size" >&5
+-$as_echo_n "checking for target address size... " >&6; }
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_CPU_BITS bits" >&5
+-$as_echo "$OPENJDK_TARGET_CPU_BITS bits" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for target address size" >&5
++printf %s "checking for target address size... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_CPU_BITS bits" >&5
++printf "%s\n" "$OPENJDK_TARGET_CPU_BITS bits" >&6; }
+ 
+ 
+   ###############################################################################
+   #
+   # Is the target little of big endian?
+   #
+-   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
+-$as_echo_n "checking whether byte ordering is bigendian... " >&6; }
+-if ${ac_cv_c_bigendian+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_cv_c_bigendian=unknown
++   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
++printf %s "checking whether byte ordering is bigendian... " >&6; }
++if test ${ac_cv_c_bigendian+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_cv_c_bigendian=unknown
+     # See if we're dealing with a universal compiler.
+     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+@@ -42213,7 +44752,8 @@ else
+ 	     typedef int dummy;
+ 
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+ 
+ 	# Check for potential -arch flags.  It is not universal unless
+ 	# there are at least two -arch flags with different values.
+@@ -42237,7 +44777,7 @@ if ac_fn_cxx_try_compile "$LINENO"; then :
+ 	 fi
+        done
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+     if test $ac_cv_c_bigendian = unknown; then
+       # See if sys/param.h defines the BYTE_ORDER macro.
+       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+@@ -42246,10 +44786,10 @@ rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ 	     #include <sys/param.h>
+ 
+ int
+-main ()
++main (void)
+ {
+-#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
+-		     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
++#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \\
++		     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \\
+ 		     && LITTLE_ENDIAN)
+ 	      bogus endian macros
+ 	     #endif
+@@ -42258,7 +44798,8 @@ main ()
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+   # It does; now see whether it defined to BIG_ENDIAN or not.
+ 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+@@ -42266,7 +44807,7 @@ if ac_fn_cxx_try_compile "$LINENO"; then :
+ 		#include <sys/param.h>
+ 
+ int
+-main ()
++main (void)
+ {
+ #if BYTE_ORDER != BIG_ENDIAN
+ 		 not big endian
+@@ -42276,14 +44817,16 @@ main ()
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+   ac_cv_c_bigendian=yes
+-else
+-  ac_cv_c_bigendian=no
++else case e in #(
++  e) ac_cv_c_bigendian=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+     fi
+     if test $ac_cv_c_bigendian = unknown; then
+       # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
+@@ -42292,7 +44835,7 @@ rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ #include <limits.h>
+ 
+ int
+-main ()
++main (void)
+ {
+ #if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
+ 	      bogus endian macros
+@@ -42302,14 +44845,15 @@ main ()
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+   # It does; now see whether it defined to _BIG_ENDIAN or not.
+ 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ #include <limits.h>
+ 
+ int
+-main ()
++main (void)
+ {
+ #ifndef _BIG_ENDIAN
+ 		 not big endian
+@@ -42319,50 +44863,55 @@ main ()
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+   ac_cv_c_bigendian=yes
+-else
+-  ac_cv_c_bigendian=no
++else case e in #(
++  e) ac_cv_c_bigendian=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+     fi
+     if test $ac_cv_c_bigendian = unknown; then
+       # Compile a test program.
+-      if test "$cross_compiling" = yes; then :
++      if test "$cross_compiling" = yes
++then :
+   # Try to guess by grepping values from an object file.
+ 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+-short int ascii_mm[] =
++unsigned short int ascii_mm[] =
+ 		  { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
+-		short int ascii_ii[] =
++		unsigned short int ascii_ii[] =
+ 		  { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
+ 		int use_ascii (int i) {
+ 		  return ascii_mm[i] + ascii_ii[i];
+ 		}
+-		short int ebcdic_ii[] =
++		unsigned short int ebcdic_ii[] =
+ 		  { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
+-		short int ebcdic_mm[] =
++		unsigned short int ebcdic_mm[] =
+ 		  { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
+ 		int use_ebcdic (int i) {
+ 		  return ebcdic_mm[i] + ebcdic_ii[i];
+ 		}
+-		extern int foo;
+-
+-int
+-main ()
+-{
+-return use_ascii (foo) == use_ebcdic (foo);
+-  ;
+-  return 0;
+-}
++		int
++		main (int argc, char **argv)
++		{
++		  /* Intimidate the compiler so that it does not
++		     optimize the arrays away.  */
++		  char *p = argv[0];
++		  ascii_mm[1] = *p++; ebcdic_mm[1] = *p++;
++		  ascii_ii[1] = *p++; ebcdic_ii[1] = *p++;
++		  return use_ascii (argc) == use_ebcdic (*p);
++		}
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
+-  if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
++if ac_fn_cxx_try_link "$LINENO"
++then :
++  if grep BIGenDianSyS conftest$ac_exeext >/dev/null; then
+ 	      ac_cv_c_bigendian=yes
+ 	    fi
+-	    if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
++	    if grep LiTTleEnDian conftest$ac_exeext >/dev/null ; then
+ 	      if test "$ac_cv_c_bigendian" = unknown; then
+ 		ac_cv_c_bigendian=no
+ 	      else
+@@ -42371,13 +44920,14 @@ if ac_fn_cxx_try_compile "$LINENO"; then :
+ 	      fi
+ 	    fi
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+-else
+-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
++    conftest$ac_exeext conftest.$ac_ext
++else case e in #(
++  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ $ac_includes_default
+ int
+-main ()
++main (void)
+ {
+ 
+ 	     /* Are we little or big endian?  From Harbison&Steele.  */
+@@ -42393,19 +44943,23 @@ main ()
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_run "$LINENO"; then :
++if ac_fn_cxx_try_run "$LINENO"
++then :
+   ac_cv_c_bigendian=no
+-else
+-  ac_cv_c_bigendian=yes
++else case e in #(
++  e) ac_cv_c_bigendian=yes ;;
++esac
+ fi
+ rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+-  conftest.$ac_objext conftest.beam conftest.$ac_ext
++  conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
++esac
+ fi
+ 
+-    fi
++    fi ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
+-$as_echo "$ac_cv_c_bigendian" >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
++printf "%s\n" "$ac_cv_c_bigendian" >&6; }
+  case $ac_cv_c_bigendian in #(
+    yes)
+      ENDIAN="big";; #(
+@@ -42657,8 +45211,8 @@ $as_echo "$ac_cv_c_bigendian" >&6; }
+     fi
+     CXXSTD_CXXFLAG="-std=gnu++98"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$CXXSTD_CXXFLAG -Werror\"" >&5
+-$as_echo_n "checking if the C++ compiler supports \"$CXXSTD_CXXFLAG -Werror\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$CXXSTD_CXXFLAG -Werror\"" >&5
++printf %s "checking if the C++ compiler supports \"$CXXSTD_CXXFLAG -Werror\"... " >&6; }
+   supports=yes
+ 
+   saved_cxxflags="$CXXFLAGS"
+@@ -42673,12 +45227,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -42687,8 +45243,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CXXFLAGS="$saved_cxxflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     :
+   else
+@@ -42701,63 +45257,73 @@ $as_echo "$supports" >&6; }
+   fi
+ 
+   if test "x$CFLAGS" != "x${ADDED_CFLAGS}"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags" >&5
+-$as_echo "$as_me: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags" >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags" >&5
++printf "%s\n" "$as_me: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags" >&2;}
+   fi
+ 
+   if test "x$CXXFLAGS" != "x${ADDED_CXXFLAGS}"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags" >&5
+-$as_echo "$as_me: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags" >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags" >&5
++printf "%s\n" "$as_me: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags" >&2;}
+   fi
+ 
+   if test "x$LDFLAGS" != "x${ADDED_LDFLAGS}"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags" >&5
+-$as_echo "$as_me: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags" >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags" >&5
++printf "%s\n" "$as_me: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags" >&2;}
+   fi
+ 
+ 
+   if test "x$ASFLAGS" != "x"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring ASFLAGS($ASFLAGS) found in environment. Use --with-extra-asflags" >&5
+-$as_echo "$as_me: WARNING: Ignoring ASFLAGS($ASFLAGS) found in environment. Use --with-extra-asflags" >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring ASFLAGS($ASFLAGS) found in environment. Use --with-extra-asflags" >&5
++printf "%s\n" "$as_me: WARNING: Ignoring ASFLAGS($ASFLAGS) found in environment. Use --with-extra-asflags" >&2;}
+   fi
+ 
+ 
+ # Check whether --with-extra-cflags was given.
+-if test "${with_extra_cflags+set}" = set; then :
++if test ${with_extra_cflags+y}
++then :
+   withval=$with_extra_cflags;
+ fi
+ 
+ 
+ 
+ # Check whether --with-extra-cxxflags was given.
+-if test "${with_extra_cxxflags+set}" = set; then :
++if test ${with_extra_cxxflags+y}
++then :
+   withval=$with_extra_cxxflags;
+ fi
+ 
+ 
+ 
+ # Check whether --with-extra-ldflags was given.
+-if test "${with_extra_ldflags+set}" = set; then :
++if test ${with_extra_ldflags+y}
++then :
+   withval=$with_extra_ldflags;
+ fi
+ 
+ 
+ 
+ # Check whether --with-extra-asflags was given.
+-if test "${with_extra_asflags+set}" = set; then :
++if test ${with_extra_asflags+y}
++then :
+   withval=$with_extra_asflags;
+ fi
+ 
+ 
+-  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags"
+-  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags"
++  # Define MUSL_LIBC
++  DEFINE_LIBC=""
++  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
++    DEFINE_LIBC="-DMUSL_LIBC"
++  fi
++
++  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags ${DEFINE_LIBC}"
++  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags ${DEFINE_LIBC}"
+   LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
+ 
+   # Hotspot needs these set in their legacy form
+-  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags"
+-  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags"
+-  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags"
+-  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags"
++  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
++  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
++  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
++  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
+   LEGACY_HOST_LDFLAGS="$LEGACY_HOST_LDFLAGS $with_extra_ldflags"
+   LEGACY_TARGET_LDFLAGS="$LEGACY_TARGET_LDFLAGS $with_extra_ldflags"
+   LEGACY_HOST_ASFLAGS="$with_extra_asflags"
+@@ -42823,8 +45389,8 @@ fi
+   NO_DELETE_NULL_POINTER_CHECKS_CFLAG="-fno-delete-null-pointer-checks"
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
+-$as_echo_n "checking if the C compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
++printf %s "checking if the C compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
+   supports=yes
+ 
+   saved_cflags="$CFLAGS"
+@@ -42840,12 +45406,14 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_c_try_compile "$LINENO"; then :
++if ac_fn_c_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -42854,8 +45422,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CFLAGS="$saved_cflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     C_COMP_SUPPORTS="yes"
+   else
+@@ -42863,8 +45431,8 @@ $as_echo "$supports" >&6; }
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
+-$as_echo_n "checking if the C++ compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
++printf %s "checking if the C++ compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
+   supports=yes
+ 
+   saved_cxxflags="$CXXFLAGS"
+@@ -42879,12 +45447,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -42893,8 +45463,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CXXFLAGS="$saved_cxxflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     CXX_COMP_SUPPORTS="yes"
+   else
+@@ -42902,13 +45472,13 @@ $as_echo "$supports" >&6; }
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
+-$as_echo_n "checking if both compilers support \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
++printf %s "checking if both compilers support \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
+   supports=no
+   if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     :
+   else
+@@ -42919,8 +45489,8 @@ $as_echo "$supports" >&6; }
+   NO_LIFETIME_DSE_CFLAG="-fno-lifetime-dse"
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
+-$as_echo_n "checking if the C compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
++printf %s "checking if the C compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
+   supports=yes
+ 
+   saved_cflags="$CFLAGS"
+@@ -42935,12 +45505,14 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_c_try_compile "$LINENO"; then :
++if ac_fn_c_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -42949,8 +45521,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CFLAGS="$saved_cflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     C_COMP_SUPPORTS="yes"
+   else
+@@ -42958,8 +45530,8 @@ $as_echo "$supports" >&6; }
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
+-$as_echo_n "checking if the C++ compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
++printf %s "checking if the C++ compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
+   supports=yes
+ 
+   saved_cxxflags="$CXXFLAGS"
+@@ -42974,12 +45546,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -42988,8 +45562,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CXXFLAGS="$saved_cxxflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     CXX_COMP_SUPPORTS="yes"
+   else
+@@ -42997,13 +45571,13 @@ $as_echo "$supports" >&6; }
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
+-$as_echo_n "checking if both compilers support \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
++printf %s "checking if both compilers support \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
+   supports=no
+   if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     :
+   else
+@@ -43024,8 +45598,8 @@ $as_echo "$supports" >&6; }
+     # Set USE_FORMAT_OVERFLOW to 1 if it does.
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"-Wformat-overflow -Werror\"" >&5
+-$as_echo_n "checking if the C compiler supports \"-Wformat-overflow -Werror\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"-Wformat-overflow -Werror\"" >&5
++printf %s "checking if the C compiler supports \"-Wformat-overflow -Werror\"... " >&6; }
+   supports=yes
+ 
+   saved_cflags="$CFLAGS"
+@@ -43040,12 +45614,14 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_c_try_compile "$LINENO"; then :
++if ac_fn_c_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -43054,8 +45630,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CFLAGS="$saved_cflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     C_COMP_SUPPORTS="yes"
+   else
+@@ -43063,8 +45639,8 @@ $as_echo "$supports" >&6; }
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"-Wformat-overflow -Werror\"" >&5
+-$as_echo_n "checking if the C++ compiler supports \"-Wformat-overflow -Werror\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"-Wformat-overflow -Werror\"" >&5
++printf %s "checking if the C++ compiler supports \"-Wformat-overflow -Werror\"... " >&6; }
+   supports=yes
+ 
+   saved_cxxflags="$CXXFLAGS"
+@@ -43079,12 +45655,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -43093,8 +45671,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CXXFLAGS="$saved_cxxflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     CXX_COMP_SUPPORTS="yes"
+   else
+@@ -43102,13 +45680,13 @@ $as_echo "$supports" >&6; }
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"-Wformat-overflow -Werror\"" >&5
+-$as_echo_n "checking if both compilers support \"-Wformat-overflow -Werror\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"-Wformat-overflow -Werror\"" >&5
++printf %s "checking if both compilers support \"-Wformat-overflow -Werror\"... " >&6; }
+   supports=no
+   if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     USE_FORMAT_OVERFLOW="1"
+   else
+@@ -43129,8 +45707,8 @@ $as_echo "$supports" >&6; }
+     #          -mno-fused-madd -fno-strict-aliasing for GCC < 4.6
+     COMPILER_FP_CONTRACT_OFF_FLAG="-ffp-contract=off"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$COMPILER_FP_CONTRACT_OFF_FLAG -Werror\"" >&5
+-$as_echo_n "checking if the C++ compiler supports \"$COMPILER_FP_CONTRACT_OFF_FLAG -Werror\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$COMPILER_FP_CONTRACT_OFF_FLAG -Werror\"" >&5
++printf %s "checking if the C++ compiler supports \"$COMPILER_FP_CONTRACT_OFF_FLAG -Werror\"... " >&6; }
+   supports=yes
+ 
+   saved_cxxflags="$CXXFLAGS"
+@@ -43145,12 +45723,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -43159,8 +45739,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CXXFLAGS="$saved_cxxflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     :
+   else
+@@ -43173,8 +45753,8 @@ $as_echo "$supports" >&6; }
+          test "$OPENJDK_TARGET_CPU_ARCH" = "ppc"; then
+         M_NO_FUSED_ADD_FLAG="-mno-fused-madd"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$M_NO_FUSED_ADD_FLAG -Werror\"" >&5
+-$as_echo_n "checking if the C++ compiler supports \"$M_NO_FUSED_ADD_FLAG -Werror\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$M_NO_FUSED_ADD_FLAG -Werror\"" >&5
++printf %s "checking if the C++ compiler supports \"$M_NO_FUSED_ADD_FLAG -Werror\"... " >&6; }
+   supports=yes
+ 
+   saved_cxxflags="$CXXFLAGS"
+@@ -43189,12 +45769,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -43203,8 +45785,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CXXFLAGS="$saved_cxxflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     :
+   else
+@@ -43213,8 +45795,8 @@ $as_echo "$supports" >&6; }
+ 
+         NO_STRICT_ALIASING_FLAG="-fno-strict-aliasing"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_STRICT_ALIASING_FLAG -Werror\"" >&5
+-$as_echo_n "checking if the C++ compiler supports \"$NO_STRICT_ALIASING_FLAG -Werror\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_STRICT_ALIASING_FLAG -Werror\"" >&5
++printf %s "checking if the C++ compiler supports \"$NO_STRICT_ALIASING_FLAG -Werror\"... " >&6; }
+   supports=yes
+ 
+   saved_cxxflags="$CXXFLAGS"
+@@ -43229,12 +45811,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -43243,8 +45827,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CXXFLAGS="$saved_cxxflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     :
+   else
+@@ -43519,8 +46103,8 @@ $as_echo "$supports" >&6; }
+   esac
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$ZERO_ARCHFLAG\"" >&5
+-$as_echo_n "checking if the C compiler supports \"$ZERO_ARCHFLAG\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$ZERO_ARCHFLAG\"" >&5
++printf %s "checking if the C compiler supports \"$ZERO_ARCHFLAG\"... " >&6; }
+   supports=yes
+ 
+   saved_cflags="$CFLAGS"
+@@ -43535,12 +46119,14 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_c_try_compile "$LINENO"; then :
++if ac_fn_c_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -43549,8 +46135,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CFLAGS="$saved_cflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     C_COMP_SUPPORTS="yes"
+   else
+@@ -43558,8 +46144,8 @@ $as_echo "$supports" >&6; }
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$ZERO_ARCHFLAG\"" >&5
+-$as_echo_n "checking if the C++ compiler supports \"$ZERO_ARCHFLAG\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$ZERO_ARCHFLAG\"" >&5
++printf %s "checking if the C++ compiler supports \"$ZERO_ARCHFLAG\"... " >&6; }
+   supports=yes
+ 
+   saved_cxxflags="$CXXFLAGS"
+@@ -43574,12 +46160,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -43588,8 +46176,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CXXFLAGS="$saved_cxxflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     CXX_COMP_SUPPORTS="yes"
+   else
+@@ -43597,13 +46185,13 @@ $as_echo "$supports" >&6; }
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$ZERO_ARCHFLAG\"" >&5
+-$as_echo_n "checking if both compilers support \"$ZERO_ARCHFLAG\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$ZERO_ARCHFLAG\"" >&5
++printf %s "checking if both compilers support \"$ZERO_ARCHFLAG\"... " >&6; }
+   supports=no
+   if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     :
+   else
+@@ -43616,8 +46204,8 @@ $as_echo "$supports" >&6; }
+   # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
+-$as_echo_n "checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
++printf %s "checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
+   supports=yes
+ 
+   saved_cflags="$CFLAGS"
+@@ -43632,12 +46220,14 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_c_try_compile "$LINENO"; then :
++if ac_fn_c_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -43646,8 +46236,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CFLAGS="$saved_cflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     C_COMP_SUPPORTS="yes"
+   else
+@@ -43655,8 +46245,8 @@ $as_echo "$supports" >&6; }
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
+-$as_echo_n "checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
++printf %s "checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
+   supports=yes
+ 
+   saved_cxxflags="$CXXFLAGS"
+@@ -43671,12 +46261,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ /* end confdefs.h.  */
+ int i;
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+ 
+-else
+-  supports=no
++else case e in #(
++  e) supports=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -43685,8 +46277,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+   CXXFLAGS="$saved_cxxflags"
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     CXX_COMP_SUPPORTS="yes"
+   else
+@@ -43694,13 +46286,13 @@ $as_echo "$supports" >&6; }
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
+-$as_echo_n "checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
++printf %s "checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
+   supports=no
+   if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
+-$as_echo "$supports" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
++printf "%s\n" "$supports" >&6; }
+   if test "x$supports" = "xyes" ; then
+     COMPILER_SUPPORTS_TARGET_BITS_FLAG=true
+   else
+@@ -43720,13 +46312,14 @@ $as_echo "$supports" >&6; }
+   # This must be done after the toolchain is setup, since we're looking at objcopy.
+   #
+   # Check whether --enable-debug-symbols was given.
+-if test "${enable_debug_symbols+set}" = set; then :
++if test ${enable_debug_symbols+y}
++then :
+   enableval=$enable_debug_symbols;
+ fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should generate debug symbols" >&5
+-$as_echo_n "checking if we should generate debug symbols... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we should generate debug symbols" >&5
++printf %s "checking if we should generate debug symbols... " >&6; }
+ 
+   if test "x$enable_debug_symbols" = "xyes" && test "x$OBJCOPY" = x; then
+     # explicit enabling of enable-debug-symbols and can't find objcopy
+@@ -43750,8 +46343,8 @@ $as_echo_n "checking if we should generate debug symbols... " >&6; }
+     fi
+   fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_DEBUG_SYMBOLS" >&5
+-$as_echo "$ENABLE_DEBUG_SYMBOLS" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ENABLE_DEBUG_SYMBOLS" >&5
++printf "%s\n" "$ENABLE_DEBUG_SYMBOLS" >&6; }
+ 
+   # Backwards compatibility. --with-native-debug-symbols is preferred post JDK-8207234,
+   # but if somebody does not specify it via configure, we still want to preserve old
+@@ -43759,17 +46352,19 @@ $as_echo "$ENABLE_DEBUG_SYMBOLS" >&6; }
+   #
+   # ZIP_DEBUGINFO_FILES
+   #
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should zip debug-info files" >&5
+-$as_echo_n "checking if we should zip debug-info files... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we should zip debug-info files" >&5
++printf %s "checking if we should zip debug-info files... " >&6; }
+   # Check whether --enable-zip-debug-info was given.
+-if test "${enable_zip_debug_info+set}" = set; then :
++if test ${enable_zip_debug_info+y}
++then :
+   enableval=$enable_zip_debug_info; enable_zip_debug_info="${enableval}"
+-else
+-  enable_zip_debug_info="yes"
++else case e in #(
++  e) enable_zip_debug_info="yes" ;;
++esac
+ fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${enable_zip_debug_info}" >&5
+-$as_echo "${enable_zip_debug_info}" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${enable_zip_debug_info}" >&5
++printf "%s\n" "${enable_zip_debug_info}" >&6; }
+ 
+   if test "x${enable_zip_debug_info}" = "xno"; then
+     ZIP_DEBUGINFO_FILES=false
+@@ -43783,27 +46378,29 @@ $as_echo "${enable_zip_debug_info}" >&6; }
+   # In addition, this must be done after ENABLE_DEBUG_SYMBOLS and ZIP_DEBUGINFO_FILES
+   # checking in order to preserve backwards compatibility post JDK-8207234.
+   #
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking what type of native debug symbols to use (this will override previous settings)" >&5
+-$as_echo_n "checking what type of native debug symbols to use (this will override previous settings)... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what type of native debug symbols to use (this will override previous settings)" >&5
++printf %s "checking what type of native debug symbols to use (this will override previous settings)... " >&6; }
+ 
+ # Check whether --with-native-debug-symbols was given.
+-if test "${with_native_debug_symbols+set}" = set; then :
++if test ${with_native_debug_symbols+y}
++then :
+   withval=$with_native_debug_symbols;
+ 
+-else
+-
++else case e in #(
++  e)
+         # Default to unset for backwards compatibility
+         with_native_debug_symbols=""
+-
++       ;;
++esac
+ fi
+ 
+   NATIVE_DEBUG_SYMBOLS=$with_native_debug_symbols
+   if test "x$NATIVE_DEBUG_SYMBOLS" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not specified" >&5
+-$as_echo "not specified" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not specified" >&5
++printf "%s\n" "not specified" >&6; }
+   else
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NATIVE_DEBUG_SYMBOLS" >&5
+-$as_echo "$NATIVE_DEBUG_SYMBOLS" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NATIVE_DEBUG_SYMBOLS" >&5
++printf "%s\n" "$NATIVE_DEBUG_SYMBOLS" >&6; }
+   fi
+   # Default is empty
+   DEBUG_BINARIES=
+@@ -43849,8 +46446,8 @@ $as_echo "$NATIVE_DEBUG_SYMBOLS" >&6; }
+   elif test "x$NATIVE_DEBUG_SYMBOLS" != x; then
+     as_fn_error $? "Allowed native debug symbols are: none, internal, external, zipped" "$LINENO" 5
+   else
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: --with-native-debug-symbols not specified. Using values from --disable-debug-symbols and --disable-zip-debug-info" >&5
+-$as_echo "$as_me: --with-native-debug-symbols not specified. Using values from --disable-debug-symbols and --disable-zip-debug-info" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: --with-native-debug-symbols not specified. Using values from --disable-debug-symbols and --disable-zip-debug-info" >&5
++printf "%s\n" "$as_me: --with-native-debug-symbols not specified. Using values from --disable-debug-symbols and --disable-zip-debug-info" >&6;}
+   fi
+ 
+ 
+@@ -43874,8 +46471,8 @@ $as_echo "$as_me: --with-native-debug-symbols not specified. Using values from -
+   # called fixpath.
+   FIXPATH=
+   if test "x$OPENJDK_BUILD_OS" = xwindows; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if fixpath can be created" >&5
+-$as_echo_n "checking if fixpath can be created... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if fixpath can be created" >&5
++printf %s "checking if fixpath can be created... " >&6; }
+     FIXPATH_SRC="$SRC_ROOT/common/src/fixpath.c"
+     FIXPATH_BIN="$OUTPUT_ROOT/fixpath.exe"
+     if test "x$OPENJDK_BUILD_OS_ENV" = xwindows.cygwin; then
+@@ -43900,26 +46497,26 @@ $as_echo_n "checking if fixpath can be created... " >&6; }
+     cd $CURDIR
+ 
+     if test ! -x $OUTPUT_ROOT/fixpath.exe; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+       cat $OUTPUT_ROOT/fixpath1.log
+       as_fn_error $? "Could not create $OUTPUT_ROOT/fixpath.exe" "$LINENO" 5
+     fi
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if fixpath.exe works" >&5
+-$as_echo_n "checking if fixpath.exe works... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if fixpath.exe works" >&5
++printf %s "checking if fixpath.exe works... " >&6; }
+     cd $OUTPUT_ROOT
+     $FIXPATH $CC $SRC_ROOT/common/src/fixpath.c -Fe$OUTPUT_ROOT/fixpath2.exe > $OUTPUT_ROOT/fixpath2.log 2>&1
+     cd $CURDIR
+     if test ! -x $OUTPUT_ROOT/fixpath2.exe; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+       cat $OUTPUT_ROOT/fixpath2.log
+       as_fn_error $? "fixpath did not work!" "$LINENO" 5
+     fi
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+     rm -f $OUTPUT_ROOT/fixpath?.??? $OUTPUT_ROOT/fixpath.obj
+   fi
+ 
+@@ -43933,61 +46530,61 @@ $as_echo "yes" >&6; }
+   # OS specific settings that we never will need to probe.
+   #
+   if test "x$OPENJDK_TARGET_OS" = xlinux; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on Linux?" >&5
+-$as_echo_n "checking what is not needed on Linux?... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what is not needed on Linux?" >&5
++printf %s "checking what is not needed on Linux?... " >&6; }
+     PULSE_NOT_NEEDED=yes
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: pulse" >&5
+-$as_echo "pulse" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: pulse" >&5
++printf "%s\n" "pulse" >&6; }
+   fi
+ 
+   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on Solaris?" >&5
+-$as_echo_n "checking what is not needed on Solaris?... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what is not needed on Solaris?" >&5
++printf %s "checking what is not needed on Solaris?... " >&6; }
+     ALSA_NOT_NEEDED=yes
+     PULSE_NOT_NEEDED=yes
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa pulse" >&5
+-$as_echo "alsa pulse" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: alsa pulse" >&5
++printf "%s\n" "alsa pulse" >&6; }
+   fi
+ 
+   if test "x$OPENJDK_TARGET_OS" = xaix; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on AIX?" >&5
+-$as_echo_n "checking what is not needed on AIX?... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what is not needed on AIX?" >&5
++printf %s "checking what is not needed on AIX?... " >&6; }
+     ALSA_NOT_NEEDED=yes
+     PULSE_NOT_NEEDED=yes
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa pulse" >&5
+-$as_echo "alsa pulse" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: alsa pulse" >&5
++printf "%s\n" "alsa pulse" >&6; }
+   fi
+ 
+ 
+   if test "x$OPENJDK_TARGET_OS" = xwindows; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on Windows?" >&5
+-$as_echo_n "checking what is not needed on Windows?... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what is not needed on Windows?" >&5
++printf %s "checking what is not needed on Windows?... " >&6; }
+     CUPS_NOT_NEEDED=yes
+     ALSA_NOT_NEEDED=yes
+     PULSE_NOT_NEEDED=yes
+     X11_NOT_NEEDED=yes
+     FONTCONFIG_NOT_NEEDED=yes
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa cups pulse x11" >&5
+-$as_echo "alsa cups pulse x11" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: alsa cups pulse x11" >&5
++printf "%s\n" "alsa cups pulse x11" >&6; }
+   fi
+ 
+   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on MacOSX?" >&5
+-$as_echo_n "checking what is not needed on MacOSX?... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what is not needed on MacOSX?" >&5
++printf %s "checking what is not needed on MacOSX?... " >&6; }
+     ALSA_NOT_NEEDED=yes
+     PULSE_NOT_NEEDED=yes
+     X11_NOT_NEEDED=yes
+     FONTCONFIG_NOT_NEEDED=yes
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa pulse x11" >&5
+-$as_echo "alsa pulse x11" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: alsa pulse x11" >&5
++printf "%s\n" "alsa pulse x11" >&6; }
+   fi
+ 
+   if test "x$OPENJDK_TARGET_OS" = xbsd; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on bsd?" >&5
+-$as_echo_n "checking what is not needed on bsd?... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what is not needed on bsd?" >&5
++printf %s "checking what is not needed on bsd?... " >&6; }
+     ALSA_NOT_NEEDED=yes
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa" >&5
+-$as_echo "alsa" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: alsa" >&5
++printf "%s\n" "alsa" >&6; }
+   fi
+ 
+   if test "x$OPENJDK" = "xfalse"; then
+@@ -44001,18 +46598,20 @@ $as_echo "alsa" >&6; }
+   # Deprecated and now ignored
+ 
+   # Check whether --enable-macosx-runtime-support was given.
+-if test "${enable_macosx_runtime_support+set}" = set; then :
++if test ${enable_macosx_runtime_support+y}
++then :
+   enableval=$enable_macosx_runtime_support;
+ fi
+ 
+   if test "x$enable_macosx_runtime_support" != x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --enable-macosx-runtime-support is deprecated and will be ignored." >&5
+-$as_echo "$as_me: WARNING: Option --enable-macosx-runtime-support is deprecated and will be ignored." >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Option --enable-macosx-runtime-support is deprecated and will be ignored." >&5
++printf "%s\n" "$as_me: WARNING: Option --enable-macosx-runtime-support is deprecated and will be ignored." >&2;}
+   fi
+ 
+ 
+ 
+ 
++
+   ###############################################################################
+   #
+   # Check for X Windows
+@@ -44043,28 +46642,58 @@ $as_echo "$as_me: WARNING: Option --enable-macosx-runtime-support is deprecated
+   fi
+ 
+   # Now let autoconf do it's magic
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5
+-$as_echo_n "checking for X... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for X" >&5
++printf %s "checking for X... " >&6; }
+ 
+ 
+ # Check whether --with-x was given.
+-if test "${with_x+set}" = set; then :
++if test ${with_x+y}
++then :
+   withval=$with_x;
+ fi
+ 
+-# $have_x is `yes', `no', `disabled', or empty when we do not yet know.
++# $have_x is 'yes', 'no', 'disabled', or empty when we do not yet know.
+ if test "x$with_x" = xno; then
+   # The user explicitly disabled X.
+   have_x=disabled
+ else
+   case $x_includes,$x_libraries in #(
+     *\'*) as_fn_error $? "cannot use X directory names containing '" "$LINENO" 5;; #(
+-    *,NONE | NONE,*) if ${ac_cv_have_x+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  # One or both of the vars are not set, and there is no cached value.
+-ac_x_includes=no ac_x_libraries=no
+-rm -f -r conftest.dir
++    *,NONE | NONE,*) if test ${ac_cv_have_x+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) # One or both of the vars are not set, and there is no cached value.
++ac_x_includes=no
++ac_x_libraries=no
++# Do we need to do anything special at all?
++ac_save_LIBS=$LIBS
++LIBS="-lX11 $LIBS"
++cat confdefs.h - <<_ACEOF >conftest.$ac_ext
++/* end confdefs.h.  */
++#include <X11/Xlib.h>
++int
++main (void)
++{
++XrmInitialize ()
++  ;
++  return 0;
++}
++_ACEOF
++if ac_fn_cxx_try_link "$LINENO"
++then :
++  # We can compile and link X programs with no special options.
++  ac_x_includes=
++  ac_x_libraries=
++fi
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
++    conftest$ac_exeext conftest.$ac_ext
++LIBS="$ac_save_LIBS"
++# If that didn't work, only try xmkmf and file system searches
++# for native compilation.
++if test x"$ac_x_includes" = xno && test "$cross_compiling" = no
++then :
++  rm -f -r conftest.dir
+ if mkdir conftest.dir; then
+   cd conftest.dir
+   cat >Imakefile <<'_ACEOF'
+@@ -44103,7 +46732,7 @@ _ACEOF
+   rm -f -r conftest.dir
+ fi
+ 
+-# Standard set of common directories for X headers.
++  # Standard set of common directories for X headers.
+ # Check X11 before X11Rn because it is often a symlink to the current release.
+ ac_x_header_dirs='
+ /usr/X11/include
+@@ -44130,6 +46759,8 @@ ac_x_header_dirs='
+ /usr/local/include/X11R5
+ /usr/local/include/X11R4
+ 
++/opt/X11/include
++
+ /usr/X386/include
+ /usr/x386/include
+ /usr/XFree86/include/X11
+@@ -44151,16 +46782,18 @@ if test "$ac_x_includes" = no; then
+ /* end confdefs.h.  */
+ #include <X11/Xlib.h>
+ _ACEOF
+-if ac_fn_cxx_try_cpp "$LINENO"; then :
++if ac_fn_cxx_try_cpp "$LINENO"
++then :
+   # We can compile using X headers with no special include directory.
+ ac_x_includes=
+-else
+-  for ac_dir in $ac_x_header_dirs; do
++else case e in #(
++  e) for ac_dir in $ac_x_header_dirs; do
+   if test -r "$ac_dir/X11/Xlib.h"; then
+     ac_x_includes=$ac_dir
+     break
+   fi
+-done
++done ;;
++esac
+ fi
+ rm -f conftest.err conftest.i conftest.$ac_ext
+ fi # $ac_x_includes = no
+@@ -44175,20 +46808,21 @@ if test "$ac_x_libraries" = no; then
+ /* end confdefs.h.  */
+ #include <X11/Xlib.h>
+ int
+-main ()
++main (void)
+ {
+ XrmInitialize ()
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   LIBS=$ac_save_LIBS
+ # We can link X programs with no special library path.
+ ac_x_libraries=
+-else
+-  LIBS=$ac_save_LIBS
+-for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g`
++else case e in #(
++  e) LIBS=$ac_save_LIBS
++for ac_dir in `printf "%s\n" "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g`
+ do
+   # Don't even attempt the hair of trying to link an X program!
+   for ac_extension in a so sl dylib la dll; do
+@@ -44197,21 +46831,25 @@ do
+       break 2
+     fi
+   done
+-done
++done ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+ fi # $ac_x_libraries = no
+ 
++fi
++# Record the results.
+ case $ac_x_includes,$ac_x_libraries in #(
+-  no,* | *,no | *\'*)
++  no,* | *,no | *\'*) :
+     # Didn't find X, or a directory has "'" in its name.
+-    ac_cv_have_x="have_x=no";; #(
+-  *)
++    ac_cv_have_x="have_x=no" ;; #(
++  *) :
+     # Record where we found X for the cache.
+     ac_cv_have_x="have_x=yes\
+ 	ac_x_includes='$ac_x_includes'\
+-	ac_x_libraries='$ac_x_libraries'"
++	ac_x_libraries='$ac_x_libraries'" ;;
++esac ;;
+ esac
+ fi
+ ;; #(
+@@ -44221,8 +46859,8 @@ fi
+ fi # $with_x != no
+ 
+ if test "$have_x" != yes; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5
+-$as_echo "$have_x" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5
++printf "%s\n" "$have_x" >&6; }
+   no_x=yes
+ else
+   # If each of the values was on the command line, it overrides each guess.
+@@ -44232,14 +46870,14 @@ else
+   ac_cv_have_x="have_x=yes\
+ 	ac_x_includes='$x_includes'\
+ 	ac_x_libraries='$x_libraries'"
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5
+-$as_echo "libraries $x_libraries, headers $x_includes" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5
++printf "%s\n" "libraries $x_libraries, headers $x_includes" >&6; }
+ fi
+ 
+   if test "$no_x" = yes; then
+   # Not all programs may use this symbol, but it does not hurt to define it.
+ 
+-$as_echo "#define X_DISPLAY_MISSING 1" >>confdefs.h
++printf "%s\n" "#define X_DISPLAY_MISSING 1" >>confdefs.h
+ 
+   X_CFLAGS= X_PRE_LIBS= X_LIBS= X_EXTRA_LIBS=
+ else
+@@ -44252,8 +46890,8 @@ else
+     X_LIBS="$X_LIBS -L$x_libraries"
+     # For Solaris; some versions of Sun CC require a space after -R and
+     # others require no space.  Words are not sufficient . . . .
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -R must be followed by a space" >&5
+-$as_echo_n "checking whether -R must be followed by a space... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether -R must be followed by a space" >&5
++printf %s "checking whether -R must be followed by a space... " >&6; }
+     ac_xsave_LIBS=$LIBS; LIBS="$LIBS -R$x_libraries"
+     ac_xsave_cxx_werror_flag=$ac_cxx_werror_flag
+     ac_cxx_werror_flag=yes
+@@ -44261,42 +46899,46 @@ $as_echo_n "checking whether -R must be followed by a space... " >&6; }
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++if ac_fn_cxx_try_link "$LINENO"
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+        X_LIBS="$X_LIBS -R$x_libraries"
+-else
+-  LIBS="$ac_xsave_LIBS -R $x_libraries"
++else case e in #(
++  e) LIBS="$ac_xsave_LIBS -R $x_libraries"
+        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++if ac_fn_cxx_try_link "$LINENO"
++then :
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+ 	  X_LIBS="$X_LIBS -R $x_libraries"
+-else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: neither works" >&5
+-$as_echo "neither works" >&6; }
++else case e in #(
++  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: neither works" >&5
++printf "%s\n" "neither works" >&6; } ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
+-    conftest$ac_exeext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
++    conftest$ac_exeext conftest.$ac_ext ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+     ac_cxx_werror_flag=$ac_xsave_cxx_werror_flag
+     LIBS=$ac_xsave_LIBS
+@@ -44316,108 +46958,108 @@ rm -f core conftest.err conftest.$ac_objext \
+     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-/* Override any GCC internal prototype to avoid an error.
+-   Use char because int might match the return type of a GCC
+-   builtin and then its argument prototype would still apply.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-char XOpenDisplay ();
++namespace conftest {
++  extern "C" int XOpenDisplay ();
++}
+ int
+-main ()
++main (void)
+ {
+-return XOpenDisplay ();
++return conftest::XOpenDisplay ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
+-
+-else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet" >&5
+-$as_echo_n "checking for dnet_ntoa in -ldnet... " >&6; }
+-if ${ac_cv_lib_dnet_dnet_ntoa+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
++if ac_fn_cxx_try_link "$LINENO"
++then :
++
++else case e in #(
++  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet" >&5
++printf %s "checking for dnet_ntoa in -ldnet... " >&6; }
++if test ${ac_cv_lib_dnet_dnet_ntoa+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_check_lib_save_LIBS=$LIBS
+ LIBS="-ldnet  $LIBS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-/* Override any GCC internal prototype to avoid an error.
+-   Use char because int might match the return type of a GCC
+-   builtin and then its argument prototype would still apply.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-char dnet_ntoa ();
++namespace conftest {
++  extern "C" int dnet_ntoa ();
++}
+ int
+-main ()
++main (void)
+ {
+-return dnet_ntoa ();
++return conftest::dnet_ntoa ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   ac_cv_lib_dnet_dnet_ntoa=yes
+-else
+-  ac_cv_lib_dnet_dnet_ntoa=no
++else case e in #(
++  e) ac_cv_lib_dnet_dnet_ntoa=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++LIBS=$ac_check_lib_save_LIBS ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_dnet_ntoa" >&5
+-$as_echo "$ac_cv_lib_dnet_dnet_ntoa" >&6; }
+-if test "x$ac_cv_lib_dnet_dnet_ntoa" = xyes; then :
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_dnet_ntoa" >&5
++printf "%s\n" "$ac_cv_lib_dnet_dnet_ntoa" >&6; }
++if test "x$ac_cv_lib_dnet_dnet_ntoa" = xyes
++then :
+   X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet"
+ fi
+ 
+     if test $ac_cv_lib_dnet_dnet_ntoa = no; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet_stub" >&5
+-$as_echo_n "checking for dnet_ntoa in -ldnet_stub... " >&6; }
+-if ${ac_cv_lib_dnet_stub_dnet_ntoa+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet_stub" >&5
++printf %s "checking for dnet_ntoa in -ldnet_stub... " >&6; }
++if test ${ac_cv_lib_dnet_stub_dnet_ntoa+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_check_lib_save_LIBS=$LIBS
+ LIBS="-ldnet_stub  $LIBS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-/* Override any GCC internal prototype to avoid an error.
+-   Use char because int might match the return type of a GCC
+-   builtin and then its argument prototype would still apply.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-char dnet_ntoa ();
++namespace conftest {
++  extern "C" int dnet_ntoa ();
++}
+ int
+-main ()
++main (void)
+ {
+-return dnet_ntoa ();
++return conftest::dnet_ntoa ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   ac_cv_lib_dnet_stub_dnet_ntoa=yes
+-else
+-  ac_cv_lib_dnet_stub_dnet_ntoa=no
++else case e in #(
++  e) ac_cv_lib_dnet_stub_dnet_ntoa=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++LIBS=$ac_check_lib_save_LIBS ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_stub_dnet_ntoa" >&5
+-$as_echo "$ac_cv_lib_dnet_stub_dnet_ntoa" >&6; }
+-if test "x$ac_cv_lib_dnet_stub_dnet_ntoa" = xyes; then :
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_stub_dnet_ntoa" >&5
++printf "%s\n" "$ac_cv_lib_dnet_stub_dnet_ntoa" >&6; }
++if test "x$ac_cv_lib_dnet_stub_dnet_ntoa" = xyes
++then :
+   X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet_stub"
+ fi
+ 
+-    fi
++    fi ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+     LIBS="$ac_xsave_LIBS"
+ 
+@@ -44430,89 +47072,92 @@ rm -f core conftest.err conftest.$ac_objext \
+     # The functions gethostbyname, getservbyname, and inet_addr are
+     # in -lbsd on LynxOS 3.0.1/i386, according to Lars Hecking.
+     ac_fn_cxx_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname"
+-if test "x$ac_cv_func_gethostbyname" = xyes; then :
++if test "x$ac_cv_func_gethostbyname" = xyes
++then :
+ 
+ fi
+ 
+     if test $ac_cv_func_gethostbyname = no; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5
+-$as_echo_n "checking for gethostbyname in -lnsl... " >&6; }
+-if ${ac_cv_lib_nsl_gethostbyname+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5
++printf %s "checking for gethostbyname in -lnsl... " >&6; }
++if test ${ac_cv_lib_nsl_gethostbyname+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_check_lib_save_LIBS=$LIBS
+ LIBS="-lnsl  $LIBS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-/* Override any GCC internal prototype to avoid an error.
+-   Use char because int might match the return type of a GCC
+-   builtin and then its argument prototype would still apply.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-char gethostbyname ();
++namespace conftest {
++  extern "C" int gethostbyname ();
++}
+ int
+-main ()
++main (void)
+ {
+-return gethostbyname ();
++return conftest::gethostbyname ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   ac_cv_lib_nsl_gethostbyname=yes
+-else
+-  ac_cv_lib_nsl_gethostbyname=no
++else case e in #(
++  e) ac_cv_lib_nsl_gethostbyname=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++LIBS=$ac_check_lib_save_LIBS ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5
+-$as_echo "$ac_cv_lib_nsl_gethostbyname" >&6; }
+-if test "x$ac_cv_lib_nsl_gethostbyname" = xyes; then :
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5
++printf "%s\n" "$ac_cv_lib_nsl_gethostbyname" >&6; }
++if test "x$ac_cv_lib_nsl_gethostbyname" = xyes
++then :
+   X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl"
+ fi
+ 
+       if test $ac_cv_lib_nsl_gethostbyname = no; then
+-	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lbsd" >&5
+-$as_echo_n "checking for gethostbyname in -lbsd... " >&6; }
+-if ${ac_cv_lib_bsd_gethostbyname+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
++	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lbsd" >&5
++printf %s "checking for gethostbyname in -lbsd... " >&6; }
++if test ${ac_cv_lib_bsd_gethostbyname+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_check_lib_save_LIBS=$LIBS
+ LIBS="-lbsd  $LIBS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-/* Override any GCC internal prototype to avoid an error.
+-   Use char because int might match the return type of a GCC
+-   builtin and then its argument prototype would still apply.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-char gethostbyname ();
++namespace conftest {
++  extern "C" int gethostbyname ();
++}
+ int
+-main ()
++main (void)
+ {
+-return gethostbyname ();
++return conftest::gethostbyname ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   ac_cv_lib_bsd_gethostbyname=yes
+-else
+-  ac_cv_lib_bsd_gethostbyname=no
++else case e in #(
++  e) ac_cv_lib_bsd_gethostbyname=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++LIBS=$ac_check_lib_save_LIBS ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bsd_gethostbyname" >&5
+-$as_echo "$ac_cv_lib_bsd_gethostbyname" >&6; }
+-if test "x$ac_cv_lib_bsd_gethostbyname" = xyes; then :
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bsd_gethostbyname" >&5
++printf "%s\n" "$ac_cv_lib_bsd_gethostbyname" >&6; }
++if test "x$ac_cv_lib_bsd_gethostbyname" = xyes
++then :
+   X_EXTRA_LIBS="$X_EXTRA_LIBS -lbsd"
+ fi
+ 
+@@ -44527,48 +47172,50 @@ fi
+     # must be given before -lnsl if both are needed.  We assume that
+     # if connect needs -lnsl, so does gethostbyname.
+     ac_fn_cxx_check_func "$LINENO" "connect" "ac_cv_func_connect"
+-if test "x$ac_cv_func_connect" = xyes; then :
++if test "x$ac_cv_func_connect" = xyes
++then :
+ 
+ fi
+ 
+     if test $ac_cv_func_connect = no; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for connect in -lsocket" >&5
+-$as_echo_n "checking for connect in -lsocket... " >&6; }
+-if ${ac_cv_lib_socket_connect+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for connect in -lsocket" >&5
++printf %s "checking for connect in -lsocket... " >&6; }
++if test ${ac_cv_lib_socket_connect+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_check_lib_save_LIBS=$LIBS
+ LIBS="-lsocket $X_EXTRA_LIBS $LIBS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-/* Override any GCC internal prototype to avoid an error.
+-   Use char because int might match the return type of a GCC
+-   builtin and then its argument prototype would still apply.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-char connect ();
++namespace conftest {
++  extern "C" int connect ();
++}
+ int
+-main ()
++main (void)
+ {
+-return connect ();
++return conftest::connect ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   ac_cv_lib_socket_connect=yes
+-else
+-  ac_cv_lib_socket_connect=no
++else case e in #(
++  e) ac_cv_lib_socket_connect=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++LIBS=$ac_check_lib_save_LIBS ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_connect" >&5
+-$as_echo "$ac_cv_lib_socket_connect" >&6; }
+-if test "x$ac_cv_lib_socket_connect" = xyes; then :
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_connect" >&5
++printf "%s\n" "$ac_cv_lib_socket_connect" >&6; }
++if test "x$ac_cv_lib_socket_connect" = xyes
++then :
+   X_EXTRA_LIBS="-lsocket $X_EXTRA_LIBS"
+ fi
+ 
+@@ -44576,48 +47223,50 @@ fi
+ 
+     # Guillermo Gomez says -lposix is necessary on A/UX.
+     ac_fn_cxx_check_func "$LINENO" "remove" "ac_cv_func_remove"
+-if test "x$ac_cv_func_remove" = xyes; then :
++if test "x$ac_cv_func_remove" = xyes
++then :
+ 
+ fi
+ 
+     if test $ac_cv_func_remove = no; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for remove in -lposix" >&5
+-$as_echo_n "checking for remove in -lposix... " >&6; }
+-if ${ac_cv_lib_posix_remove+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for remove in -lposix" >&5
++printf %s "checking for remove in -lposix... " >&6; }
++if test ${ac_cv_lib_posix_remove+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_check_lib_save_LIBS=$LIBS
+ LIBS="-lposix  $LIBS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-/* Override any GCC internal prototype to avoid an error.
+-   Use char because int might match the return type of a GCC
+-   builtin and then its argument prototype would still apply.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-char remove ();
++namespace conftest {
++  extern "C" int remove ();
++}
+ int
+-main ()
++main (void)
+ {
+-return remove ();
++return conftest::remove ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   ac_cv_lib_posix_remove=yes
+-else
+-  ac_cv_lib_posix_remove=no
++else case e in #(
++  e) ac_cv_lib_posix_remove=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++LIBS=$ac_check_lib_save_LIBS ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix_remove" >&5
+-$as_echo "$ac_cv_lib_posix_remove" >&6; }
+-if test "x$ac_cv_lib_posix_remove" = xyes; then :
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix_remove" >&5
++printf "%s\n" "$ac_cv_lib_posix_remove" >&6; }
++if test "x$ac_cv_lib_posix_remove" = xyes
++then :
+   X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix"
+ fi
+ 
+@@ -44625,48 +47274,50 @@ fi
+ 
+     # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay.
+     ac_fn_cxx_check_func "$LINENO" "shmat" "ac_cv_func_shmat"
+-if test "x$ac_cv_func_shmat" = xyes; then :
++if test "x$ac_cv_func_shmat" = xyes
++then :
+ 
+ fi
+ 
+     if test $ac_cv_func_shmat = no; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shmat in -lipc" >&5
+-$as_echo_n "checking for shmat in -lipc... " >&6; }
+-if ${ac_cv_lib_ipc_shmat+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shmat in -lipc" >&5
++printf %s "checking for shmat in -lipc... " >&6; }
++if test ${ac_cv_lib_ipc_shmat+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_check_lib_save_LIBS=$LIBS
+ LIBS="-lipc  $LIBS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-/* Override any GCC internal prototype to avoid an error.
+-   Use char because int might match the return type of a GCC
+-   builtin and then its argument prototype would still apply.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-char shmat ();
++namespace conftest {
++  extern "C" int shmat ();
++}
+ int
+-main ()
++main (void)
+ {
+-return shmat ();
++return conftest::shmat ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   ac_cv_lib_ipc_shmat=yes
+-else
+-  ac_cv_lib_ipc_shmat=no
++else case e in #(
++  e) ac_cv_lib_ipc_shmat=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++LIBS=$ac_check_lib_save_LIBS ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ipc_shmat" >&5
+-$as_echo "$ac_cv_lib_ipc_shmat" >&6; }
+-if test "x$ac_cv_lib_ipc_shmat" = xyes; then :
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ipc_shmat" >&5
++printf "%s\n" "$ac_cv_lib_ipc_shmat" >&6; }
++if test "x$ac_cv_lib_ipc_shmat" = xyes
++then :
+   X_EXTRA_LIBS="$X_EXTRA_LIBS -lipc"
+ fi
+ 
+@@ -44682,43 +47333,44 @@ fi
+   # These have to be linked with before -lX11, unlike the other
+   # libraries we check for below, so use a different variable.
+   # John Interrante, Karl Berry
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for IceConnectionNumber in -lICE" >&5
+-$as_echo_n "checking for IceConnectionNumber in -lICE... " >&6; }
+-if ${ac_cv_lib_ICE_IceConnectionNumber+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for IceConnectionNumber in -lICE" >&5
++printf %s "checking for IceConnectionNumber in -lICE... " >&6; }
++if test ${ac_cv_lib_ICE_IceConnectionNumber+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_check_lib_save_LIBS=$LIBS
+ LIBS="-lICE $X_EXTRA_LIBS $LIBS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-/* Override any GCC internal prototype to avoid an error.
+-   Use char because int might match the return type of a GCC
+-   builtin and then its argument prototype would still apply.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-char IceConnectionNumber ();
++namespace conftest {
++  extern "C" int IceConnectionNumber ();
++}
+ int
+-main ()
++main (void)
+ {
+-return IceConnectionNumber ();
++return conftest::IceConnectionNumber ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   ac_cv_lib_ICE_IceConnectionNumber=yes
+-else
+-  ac_cv_lib_ICE_IceConnectionNumber=no
++else case e in #(
++  e) ac_cv_lib_ICE_IceConnectionNumber=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++LIBS=$ac_check_lib_save_LIBS ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ICE_IceConnectionNumber" >&5
+-$as_echo "$ac_cv_lib_ICE_IceConnectionNumber" >&6; }
+-if test "x$ac_cv_lib_ICE_IceConnectionNumber" = xyes; then :
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ICE_IceConnectionNumber" >&5
++printf "%s\n" "$ac_cv_lib_ICE_IceConnectionNumber" >&6; }
++if test "x$ac_cv_lib_ICE_IceConnectionNumber" = xyes
++then :
+   X_PRE_LIBS="$X_PRE_LIBS -lSM -lICE"
+ fi
+ 
+@@ -44798,27 +47450,28 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
+   CFLAGS="$CFLAGS $X_CFLAGS"
+ 
+   # Need to include Xlib.h and Xutil.h to avoid "present but cannot be compiled" warnings on Solaris 10
+-  for ac_header in X11/extensions/shape.h X11/extensions/Xrender.h X11/extensions/XTest.h X11/Intrinsic.h
++         for ac_header in X11/extensions/shape.h X11/extensions/Xrender.h X11/extensions/XTest.h X11/Intrinsic.h
+ do :
+-  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
++  as_ac_Header=`printf "%s\n" "ac_cv_header_$ac_header" | sed "$as_sed_sh"`
+ ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "
+         # include <X11/Xlib.h>
+         # include <X11/Xutil.h>
+ 
+ 
+ "
+-if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
++if eval test \"x\$"$as_ac_Header"\" = x"yes"
++then :
+   cat >>confdefs.h <<_ACEOF
+-#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
++#define `printf "%s\n" "HAVE_$ac_header" | sed "$as_sed_cpp"` 1
+ _ACEOF
+  X11_A_OK=yes
+-else
+-  X11_A_OK=no; break
++else case e in #(
++  e) X11_A_OK=no; break ;;
++esac
+ fi
+ 
+ done
+ 
+-
+   CFLAGS="$OLD_CFLAGS"
+   ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+@@ -44872,21 +47525,23 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+   #
+ 
+ # Check whether --with-cups was given.
+-if test "${with_cups+set}" = set; then :
++if test ${with_cups+y}
++then :
+   withval=$with_cups;
+ fi
+ 
+ 
+ # Check whether --with-cups-include was given.
+-if test "${with_cups_include+set}" = set; then :
++if test ${with_cups_include+y}
++then :
+   withval=$with_cups_include;
+ fi
+ 
+ 
+   if test "x$CUPS_NOT_NEEDED" = xyes; then
+     if test "x${with_cups}" != x || test "x${with_cups_include}" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cups not used, so --with-cups is ignored" >&5
+-$as_echo "$as_me: WARNING: cups not used, so --with-cups is ignored" >&2;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cups not used, so --with-cups is ignored" >&5
++printf "%s\n" "$as_me: WARNING: cups not used, so --with-cups is ignored" >&2;}
+     fi
+     CUPS_CFLAGS=
+   else
+@@ -44926,8 +47581,8 @@ $as_echo "$as_me: WARNING: cups not used, so --with-cups is ignored" >&2;}
+       resource=${builddep_cups}
+     fi
+     if test "x$resource" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for cups" >&5
+-$as_echo "$as_me: Using builddeps $resource for cups" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for cups" >&5
++printf "%s\n" "$as_me: Using builddeps $resource for cups" >&6;}
+       # If the resource in the builddeps.conf file is an existing directory,
+       # for example /java/linux/cups
+       if test -d ${resource}; then
+@@ -44947,8 +47602,8 @@ $as_echo "$as_me: Using builddeps $resource for cups" >&6;}
+   extension=${filename#*.}
+   installdir=$with_builddeps_dir/$filebase
+   if test ! -f $installdir/$filename.unpacked; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency cups from $with_builddeps_server/$resource and installing into $installdir" >&5
+-$as_echo "$as_me: Downloading build dependency cups from $with_builddeps_server/$resource and installing into $installdir" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Downloading build dependency cups from $with_builddeps_server/$resource and installing into $installdir" >&5
++printf "%s\n" "$as_me: Downloading build dependency cups from $with_builddeps_server/$resource and installing into $installdir" >&6;}
+     if test ! -d $installdir; then
+       mkdir -p $installdir
+     fi
+@@ -45051,13 +47706,14 @@ $as_echo "$as_me: Downloading build dependency cups from $with_builddeps_server/
+     fi
+     if test "x$CUPS_FOUND" = xno; then
+       # Are the cups headers installed in the default /usr/include location?
+-      for ac_header in cups/cups.h cups/ppd.h
++             for ac_header in cups/cups.h cups/ppd.h
+ do :
+-  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+-ac_fn_cxx_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
+-if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
++  as_ac_Header=`printf "%s\n" "ac_cv_header_$ac_header" | sed "$as_sed_sh"`
++ac_fn_cxx_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
++if eval test \"x\$"$as_ac_Header"\" = x"yes"
++then :
+   cat >>confdefs.h <<_ACEOF
+-#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
++#define `printf "%s\n" "HAVE_$ac_header" | sed "$as_sed_cpp"` 1
+ _ACEOF
+ 
+             CUPS_FOUND=yes
+@@ -45068,13 +47724,12 @@ _ACEOF
+ fi
+ 
+ done
+-
+     fi
+     if test "x$CUPS_FOUND" = xno; then
+       # Getting nervous now? Lets poke around for standard Solaris third-party
+       # package installation locations.
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cups headers" >&5
+-$as_echo_n "checking for cups headers... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for cups headers" >&5
++printf %s "checking for cups headers... " >&6; }
+       if test -s $SYSROOT/opt/sfw/cups/include/cups/cups.h; then
+         # An SFW package seems to be installed!
+         CUPS_FOUND=yes
+@@ -45084,8 +47739,8 @@ $as_echo_n "checking for cups headers... " >&6; }
+         CUPS_FOUND=yes
+         CUPS_CFLAGS="-I$SYSROOT/opt/csw/include"
+       fi
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUPS_FOUND" >&5
+-$as_echo "$CUPS_FOUND" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CUPS_FOUND" >&5
++printf "%s\n" "$CUPS_FOUND" >&6; }
+     fi
+     if test "x$CUPS_FOUND" = xno; then
+ 
+@@ -45128,19 +47783,22 @@ $as_echo "$CUPS_FOUND" >&6; }
+ 
+ 
+ # Check whether --with-freetype was given.
+-if test "${with_freetype+set}" = set; then :
++if test ${with_freetype+y}
++then :
+   withval=$with_freetype;
+ fi
+ 
+ 
+ # Check whether --with-freetype-include was given.
+-if test "${with_freetype_include+set}" = set; then :
++if test ${with_freetype_include+y}
++then :
+   withval=$with_freetype_include;
+ fi
+ 
+ 
+ # Check whether --with-freetype-lib was given.
+-if test "${with_freetype_lib+set}" = set; then :
++if test ${with_freetype_lib+y}
++then :
+   withval=$with_freetype_lib;
+ fi
+ 
+@@ -45221,29 +47879,29 @@ fi
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     # Include file found, let's continue the sanity check.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
+-$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
++printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
+     FOUND_FREETYPE=yes
+ 
+     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
+     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
+-$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
++printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
+       FOUND_FREETYPE=no
+     fi
+   fi
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
+-$as_echo_n "checking for freetype includes... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
+-$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
++printf %s "checking for freetype includes... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
++printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
+     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
+-$as_echo_n "checking for freetype libraries... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
+-$as_echo "$FREETYPE_LIB_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
++printf %s "checking for freetype libraries... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
++printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
+   fi
+ 
+       if test "x$FOUND_FREETYPE" != "xyes" ; then
+@@ -45261,17 +47919,17 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
+           if test "x$PKG_CONFIG" != "x" ; then
+ 
+ pkg_failed=no
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FREETYPE" >&5
+-$as_echo_n "checking for FREETYPE... " >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for FREETYPE" >&5
++printf %s "checking for FREETYPE... " >&6; }
+ 
+ if test -n "$FREETYPE_CFLAGS"; then
+     pkg_cv_FREETYPE_CFLAGS="$FREETYPE_CFLAGS"
+  elif test -n "$PKG_CONFIG"; then
+     if test -n "$PKG_CONFIG" && \
+-    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5
++    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5
+   ($PKG_CONFIG --exists --print-errors "freetype2") 2>&5
+   ac_status=$?
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; }; then
+   pkg_cv_FREETYPE_CFLAGS=`$PKG_CONFIG --cflags "freetype2" 2>/dev/null`
+ else
+@@ -45284,10 +47942,10 @@ if test -n "$FREETYPE_LIBS"; then
+     pkg_cv_FREETYPE_LIBS="$FREETYPE_LIBS"
+  elif test -n "$PKG_CONFIG"; then
+     if test -n "$PKG_CONFIG" && \
+-    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5
++    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5
+   ($PKG_CONFIG --exists --print-errors "freetype2") 2>&5
+   ac_status=$?
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; }; then
+   pkg_cv_FREETYPE_LIBS=`$PKG_CONFIG --libs "freetype2" 2>/dev/null`
+ else
+@@ -45314,23 +47972,23 @@ fi
+ 	# Put the nasty error message in config.log where it belongs
+ 	echo "$FREETYPE_PKG_ERRORS" >&5
+ 
+-	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+                 FOUND_FREETYPE=no
+ elif test $pkg_failed = untried; then
+ 	FOUND_FREETYPE=no
+ else
+ 	FREETYPE_CFLAGS=$pkg_cv_FREETYPE_CFLAGS
+ 	FREETYPE_LIBS=$pkg_cv_FREETYPE_LIBS
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+ 	FOUND_FREETYPE=yes
+ fi
+             if test "x$FOUND_FREETYPE" = "xyes" ; then
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype" >&5
+-$as_echo_n "checking for freetype... " >&6; }
+-              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (using pkg-config)" >&5
+-$as_echo "yes (using pkg-config)" >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype" >&5
++printf %s "checking for freetype... " >&6; }
++              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes (using pkg-config)" >&5
++printf "%s\n" "yes (using pkg-config)" >&6; }
+             fi
+           fi
+         fi
+@@ -45360,29 +48018,29 @@ $as_echo "yes (using pkg-config)" >&6; }
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     # Include file found, let's continue the sanity check.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
+-$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
++printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
+     FOUND_FREETYPE=yes
+ 
+     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
+     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
+-$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
++printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
+       FOUND_FREETYPE=no
+     fi
+   fi
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
+-$as_echo_n "checking for freetype includes... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
+-$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
++printf %s "checking for freetype includes... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
++printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
+     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
+-$as_echo_n "checking for freetype libraries... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
+-$as_echo "$FREETYPE_LIB_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
++printf %s "checking for freetype libraries... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
++printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
+   fi
+ 
+           if test "x$FOUND_FREETYPE" != "xyes" ; then
+@@ -45406,29 +48064,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     # Include file found, let's continue the sanity check.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
+-$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
++printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
+     FOUND_FREETYPE=yes
+ 
+     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
+     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
+-$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
++printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
+       FOUND_FREETYPE=no
+     fi
+   fi
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
+-$as_echo_n "checking for freetype includes... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
+-$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
++printf %s "checking for freetype includes... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
++printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
+     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
+-$as_echo_n "checking for freetype libraries... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
+-$as_echo "$FREETYPE_LIB_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
++printf %s "checking for freetype libraries... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
++printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
+   fi
+ 
+           fi
+@@ -45453,29 +48111,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     # Include file found, let's continue the sanity check.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
+-$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
++printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
+     FOUND_FREETYPE=yes
+ 
+     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
+     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
+-$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
++printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
+       FOUND_FREETYPE=no
+     fi
+   fi
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
+-$as_echo_n "checking for freetype includes... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
+-$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
++printf %s "checking for freetype includes... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
++printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
+     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
+-$as_echo_n "checking for freetype libraries... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
+-$as_echo "$FREETYPE_LIB_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
++printf %s "checking for freetype libraries... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
++printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
+   fi
+ 
+           if test "x$FOUND_FREETYPE" != "xyes" ; then
+@@ -45499,29 +48157,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     # Include file found, let's continue the sanity check.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
+-$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
++printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
+     FOUND_FREETYPE=yes
+ 
+     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
+     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
+-$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
++printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
+       FOUND_FREETYPE=no
+     fi
+   fi
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
+-$as_echo_n "checking for freetype includes... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
+-$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
++printf %s "checking for freetype includes... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
++printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
+     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
+-$as_echo_n "checking for freetype libraries... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
+-$as_echo "$FREETYPE_LIB_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
++printf %s "checking for freetype libraries... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
++printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
+   fi
+ 
+           fi
+@@ -45548,29 +48206,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     # Include file found, let's continue the sanity check.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
+-$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
++printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
+     FOUND_FREETYPE=yes
+ 
+     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
+     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
+-$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
++printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
+       FOUND_FREETYPE=no
+     fi
+   fi
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
+-$as_echo_n "checking for freetype includes... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
+-$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
++printf %s "checking for freetype includes... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
++printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
+     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
+-$as_echo_n "checking for freetype libraries... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
+-$as_echo "$FREETYPE_LIB_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
++printf %s "checking for freetype libraries... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
++printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
+   fi
+ 
+         fi
+@@ -45596,29 +48254,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     # Include file found, let's continue the sanity check.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
+-$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
++printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
+     FOUND_FREETYPE=yes
+ 
+     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
+     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
+-$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
++printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
+       FOUND_FREETYPE=no
+     fi
+   fi
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
+-$as_echo_n "checking for freetype includes... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
+-$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
++printf %s "checking for freetype includes... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
++printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
+     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
+-$as_echo_n "checking for freetype libraries... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
+-$as_echo "$FREETYPE_LIB_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
++printf %s "checking for freetype libraries... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
++printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
+   fi
+ 
+         fi
+@@ -45644,29 +48302,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     # Include file found, let's continue the sanity check.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
+-$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
++printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
+     FOUND_FREETYPE=yes
+ 
+     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
+     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
+-$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
++printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
+       FOUND_FREETYPE=no
+     fi
+   fi
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
+-$as_echo_n "checking for freetype includes... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
+-$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
++printf %s "checking for freetype includes... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
++printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
+     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
+-$as_echo_n "checking for freetype libraries... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
+-$as_echo "$FREETYPE_LIB_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
++printf %s "checking for freetype libraries... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
++printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
+   fi
+ 
+         fi
+@@ -45693,29 +48351,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     # Include file found, let's continue the sanity check.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
+-$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
++printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
+     FOUND_FREETYPE=yes
+ 
+     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
+     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
+-$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
++printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
+       FOUND_FREETYPE=no
+     fi
+   fi
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
+-$as_echo_n "checking for freetype includes... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
+-$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
++printf %s "checking for freetype includes... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
++printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
+     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
+-$as_echo_n "checking for freetype libraries... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
+-$as_echo "$FREETYPE_LIB_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
++printf %s "checking for freetype libraries... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
++printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
+   fi
+ 
+         fi
+@@ -45742,29 +48400,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     # Include file found, let's continue the sanity check.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
+-$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
++printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
+     FOUND_FREETYPE=yes
+ 
+     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
+     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
+-$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
++printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
+       FOUND_FREETYPE=no
+     fi
+   fi
+ 
+   if test "x$FOUND_FREETYPE" = "xyes"; then
+     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
+-$as_echo_n "checking for freetype includes... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
+-$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
++printf %s "checking for freetype includes... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
++printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
+     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
+-$as_echo_n "checking for freetype libraries... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
+-$as_echo "$FREETYPE_LIB_PATH" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
++printf %s "checking for freetype libraries... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
++printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
+   fi
+ 
+         fi
+@@ -45819,8 +48477,8 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
+     fi
+   fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: Using freetype: $FREETYPE_TO_USE" >&5
+-$as_echo "Using freetype: $FREETYPE_TO_USE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: Using freetype: $FREETYPE_TO_USE" >&5
++printf "%s\n" "Using freetype: $FREETYPE_TO_USE" >&6; }
+ 
+ 
+ 
+@@ -45834,27 +48492,30 @@ $as_echo "Using freetype: $FREETYPE_TO_USE" >&6; }
+   #
+ 
+ # Check whether --with-alsa was given.
+-if test "${with_alsa+set}" = set; then :
++if test ${with_alsa+y}
++then :
+   withval=$with_alsa;
+ fi
+ 
+ 
+ # Check whether --with-alsa-include was given.
+-if test "${with_alsa_include+set}" = set; then :
++if test ${with_alsa_include+y}
++then :
+   withval=$with_alsa_include;
+ fi
+ 
+ 
+ # Check whether --with-alsa-lib was given.
+-if test "${with_alsa_lib+set}" = set; then :
++if test ${with_alsa_lib+y}
++then :
+   withval=$with_alsa_lib;
+ fi
+ 
+ 
+   if test "x$ALSA_NOT_NEEDED" = xyes; then
+     if test "x${with_alsa}" != x || test "x${with_alsa_include}" != x || test "x${with_alsa_lib}" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: alsa not used, so --with-alsa is ignored" >&5
+-$as_echo "$as_me: WARNING: alsa not used, so --with-alsa is ignored" >&2;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: alsa not used, so --with-alsa is ignored" >&5
++printf "%s\n" "$as_me: WARNING: alsa not used, so --with-alsa is ignored" >&2;}
+     fi
+     ALSA_CFLAGS=
+     ALSA_LIBS=
+@@ -45900,8 +48561,8 @@ $as_echo "$as_me: WARNING: alsa not used, so --with-alsa is ignored" >&2;}
+       resource=${builddep_alsa}
+     fi
+     if test "x$resource" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for alsa" >&5
+-$as_echo "$as_me: Using builddeps $resource for alsa" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for alsa" >&5
++printf "%s\n" "$as_me: Using builddeps $resource for alsa" >&6;}
+       # If the resource in the builddeps.conf file is an existing directory,
+       # for example /java/linux/cups
+       if test -d ${resource}; then
+@@ -45921,8 +48582,8 @@ $as_echo "$as_me: Using builddeps $resource for alsa" >&6;}
+   extension=${filename#*.}
+   installdir=$with_builddeps_dir/$filebase
+   if test ! -f $installdir/$filename.unpacked; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency alsa from $with_builddeps_server/$resource and installing into $installdir" >&5
+-$as_echo "$as_me: Downloading build dependency alsa from $with_builddeps_server/$resource and installing into $installdir" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Downloading build dependency alsa from $with_builddeps_server/$resource and installing into $installdir" >&5
++printf "%s\n" "$as_me: Downloading build dependency alsa from $with_builddeps_server/$resource and installing into $installdir" >&6;}
+     if test ! -d $installdir; then
+       mkdir -p $installdir
+     fi
+@@ -46030,17 +48691,17 @@ $as_echo "$as_me: Downloading build dependency alsa from $with_builddeps_server/
+       if test "x$ALSA_FOUND" = xno; then
+ 
+ pkg_failed=no
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ALSA" >&5
+-$as_echo_n "checking for ALSA... " >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ALSA" >&5
++printf %s "checking for ALSA... " >&6; }
+ 
+ if test -n "$ALSA_CFLAGS"; then
+     pkg_cv_ALSA_CFLAGS="$ALSA_CFLAGS"
+  elif test -n "$PKG_CONFIG"; then
+     if test -n "$PKG_CONFIG" && \
+-    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5
++    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5
+   ($PKG_CONFIG --exists --print-errors "alsa") 2>&5
+   ac_status=$?
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; }; then
+   pkg_cv_ALSA_CFLAGS=`$PKG_CONFIG --cflags "alsa" 2>/dev/null`
+ else
+@@ -46053,10 +48714,10 @@ if test -n "$ALSA_LIBS"; then
+     pkg_cv_ALSA_LIBS="$ALSA_LIBS"
+  elif test -n "$PKG_CONFIG"; then
+     if test -n "$PKG_CONFIG" && \
+-    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5
++    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5
+   ($PKG_CONFIG --exists --print-errors "alsa") 2>&5
+   ac_status=$?
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; }; then
+   pkg_cv_ALSA_LIBS=`$PKG_CONFIG --libs "alsa" 2>/dev/null`
+ else
+@@ -46083,40 +48744,39 @@ fi
+ 	# Put the nasty error message in config.log where it belongs
+ 	echo "$ALSA_PKG_ERRORS" >&5
+ 
+-	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+                 ALSA_FOUND=no
+ elif test $pkg_failed = untried; then
+ 	ALSA_FOUND=no
+ else
+ 	ALSA_CFLAGS=$pkg_cv_ALSA_CFLAGS
+ 	ALSA_LIBS=$pkg_cv_ALSA_LIBS
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+ 	ALSA_FOUND=yes
+ fi
+       fi
+     fi
+     if test "x$ALSA_FOUND" = xno; then
+-      for ac_header in alsa/asoundlib.h
++             for ac_header in alsa/asoundlib.h
+ do :
+-  ac_fn_cxx_check_header_mongrel "$LINENO" "alsa/asoundlib.h" "ac_cv_header_alsa_asoundlib_h" "$ac_includes_default"
+-if test "x$ac_cv_header_alsa_asoundlib_h" = xyes; then :
+-  cat >>confdefs.h <<_ACEOF
+-#define HAVE_ALSA_ASOUNDLIB_H 1
+-_ACEOF
++  ac_fn_cxx_check_header_compile "$LINENO" "alsa/asoundlib.h" "ac_cv_header_alsa_asoundlib_h" "$ac_includes_default"
++if test "x$ac_cv_header_alsa_asoundlib_h" = xyes
++then :
++  printf "%s\n" "#define HAVE_ALSA_ASOUNDLIB_H 1" >>confdefs.h
+ 
+             ALSA_FOUND=yes
+             ALSA_CFLAGS=-Iignoreme
+             ALSA_LIBS=-lasound
+             DEFAULT_ALSA=yes
+ 
+-else
+-  ALSA_FOUND=no
++else case e in #(
++  e) ALSA_FOUND=no ;;
++esac
+ fi
+ 
+ done
+-
+     fi
+     if test "x$ALSA_FOUND" = xno; then
+ 
+@@ -46159,13 +48819,15 @@ done
+ 
+ 
+ # Check whether --with-fontconfig was given.
+-if test "${with_fontconfig+set}" = set; then :
++if test ${with_fontconfig+y}
++then :
+   withval=$with_fontconfig;
+ fi
+ 
+ 
+ # Check whether --with-fontconfig-include was given.
+-if test "${with_fontconfig_include+set}" = set; then :
++if test ${with_fontconfig_include+y}
++then :
+   withval=$with_fontconfig_include;
+ fi
+ 
+@@ -46173,8 +48835,8 @@ fi
+   if test "x$FONTCONFIG_NOT_NEEDED" = xyes; then
+     if (test "x${with_fontconfig}" != x && test "x${with_fontconfig}" != xno) || \
+         (test "x${with_fontconfig_include}" != x && test "x${with_fontconfig_include}" != xno); then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: fontconfig not used, so --with-fontconfig[-*] is ignored" >&5
+-$as_echo "$as_me: WARNING: fontconfig not used, so --with-fontconfig[-*] is ignored" >&2;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: fontconfig not used, so --with-fontconfig[-*] is ignored" >&5
++printf "%s\n" "$as_me: WARNING: fontconfig not used, so --with-fontconfig[-*] is ignored" >&2;}
+     fi
+     FONTCONFIG_CFLAGS=
+   else
+@@ -46185,38 +48847,37 @@ $as_echo "$as_me: WARNING: fontconfig not used, so --with-fontconfig[-*] is igno
+     fi
+ 
+     if test "x${with_fontconfig}" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fontconfig headers" >&5
+-$as_echo_n "checking for fontconfig headers... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fontconfig headers" >&5
++printf %s "checking for fontconfig headers... " >&6; }
+       if test -s "${with_fontconfig}/include/fontconfig/fontconfig.h"; then
+         FONTCONFIG_CFLAGS="-I${with_fontconfig}/include"
+         FONTCONFIG_FOUND=yes
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FONTCONFIG_FOUND" >&5
+-$as_echo "$FONTCONFIG_FOUND" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FONTCONFIG_FOUND" >&5
++printf "%s\n" "$FONTCONFIG_FOUND" >&6; }
+       else
+         as_fn_error $? "Can't find 'include/fontconfig/fontconfig.h' under ${with_fontconfig} given with the --with-fontconfig option." "$LINENO" 5
+       fi
+     fi
+     if test "x${with_fontconfig_include}" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fontconfig headers" >&5
+-$as_echo_n "checking for fontconfig headers... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fontconfig headers" >&5
++printf %s "checking for fontconfig headers... " >&6; }
+       if test -s "${with_fontconfig_include}/fontconfig/fontconfig.h"; then
+         FONTCONFIG_CFLAGS="-I${with_fontconfig_include}"
+         FONTCONFIG_FOUND=yes
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FONTCONFIG_FOUND" >&5
+-$as_echo "$FONTCONFIG_FOUND" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FONTCONFIG_FOUND" >&5
++printf "%s\n" "$FONTCONFIG_FOUND" >&6; }
+       else
+         as_fn_error $? "Can't find 'fontconfig/fontconfig.h' under ${with_fontconfig_include} given with the --with-fontconfig-include option." "$LINENO" 5
+       fi
+     fi
+     if test "x$FONTCONFIG_FOUND" = xno; then
+       # Are the fontconfig headers installed in the default /usr/include location?
+-      for ac_header in fontconfig/fontconfig.h
++             for ac_header in fontconfig/fontconfig.h
+ do :
+-  ac_fn_cxx_check_header_mongrel "$LINENO" "fontconfig/fontconfig.h" "ac_cv_header_fontconfig_fontconfig_h" "$ac_includes_default"
+-if test "x$ac_cv_header_fontconfig_fontconfig_h" = xyes; then :
+-  cat >>confdefs.h <<_ACEOF
+-#define HAVE_FONTCONFIG_FONTCONFIG_H 1
+-_ACEOF
++  ac_fn_cxx_check_header_compile "$LINENO" "fontconfig/fontconfig.h" "ac_cv_header_fontconfig_fontconfig_h" "$ac_includes_default"
++if test "x$ac_cv_header_fontconfig_fontconfig_h" = xyes
++then :
++  printf "%s\n" "#define HAVE_FONTCONFIG_FONTCONFIG_H 1" >>confdefs.h
+ 
+           FONTCONFIG_FOUND=yes
+           FONTCONFIG_CFLAGS=
+@@ -46225,7 +48886,6 @@ _ACEOF
+ fi
+ 
+ done
+-
+     fi
+     if test "x$FONTCONFIG_FOUND" = xno; then
+ 
+@@ -46272,48 +48932,54 @@ done
+   #
+ 
+   USE_EXTERNAL_LIBJPEG=true
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -ljpeg" >&5
+-$as_echo_n "checking for main in -ljpeg... " >&6; }
+-if ${ac_cv_lib_jpeg_main+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for main in -ljpeg" >&5
++printf %s "checking for main in -ljpeg... " >&6; }
++if test ${ac_cv_lib_jpeg_main+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_check_lib_save_LIBS=$LIBS
+ LIBS="-ljpeg  $LIBS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-
++namespace conftest {
++  extern "C" int main ();
++}
+ int
+-main ()
++main (void)
+ {
+-return main ();
++return conftest::main ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   ac_cv_lib_jpeg_main=yes
+-else
+-  ac_cv_lib_jpeg_main=no
++else case e in #(
++  e) ac_cv_lib_jpeg_main=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++LIBS=$ac_check_lib_save_LIBS ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_jpeg_main" >&5
+-$as_echo "$ac_cv_lib_jpeg_main" >&6; }
+-if test "x$ac_cv_lib_jpeg_main" = xyes; then :
+-  cat >>confdefs.h <<_ACEOF
+-#define HAVE_LIBJPEG 1
+-_ACEOF
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_jpeg_main" >&5
++printf "%s\n" "$ac_cv_lib_jpeg_main" >&6; }
++if test "x$ac_cv_lib_jpeg_main" = xyes
++then :
++  printf "%s\n" "#define HAVE_LIBJPEG 1" >>confdefs.h
+ 
+   LIBS="-ljpeg $LIBS"
+ 
+-else
+-   USE_EXTERNAL_LIBJPEG=false
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: Will use jpeg decoder bundled with the OpenJDK source" >&5
+-$as_echo "$as_me: Will use jpeg decoder bundled with the OpenJDK source" >&6;}
+-
++else case e in #(
++  e)  USE_EXTERNAL_LIBJPEG=false
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use jpeg decoder bundled with the OpenJDK source" >&5
++printf "%s\n" "$as_me: Will use jpeg decoder bundled with the OpenJDK source" >&6;}
++   ;;
++esac
+ fi
+ 
+ 
+@@ -46325,14 +48991,15 @@ fi
+ 
+ 
+ # Check whether --with-giflib was given.
+-if test "${with_giflib+set}" = set; then :
++if test ${with_giflib+y}
++then :
+   withval=$with_giflib;
+ fi
+ 
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for which giflib to use" >&5
+-$as_echo_n "checking for which giflib to use... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for which giflib to use" >&5
++printf %s "checking for which giflib to use... " >&6; }
+ 
+   # default is bundled
+   DEFAULT_GIFLIB=bundled
+@@ -46344,65 +49011,66 @@ $as_echo_n "checking for which giflib to use... " >&6; }
+     with_giflib=${DEFAULT_GIFLIB}
+   fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_giflib}" >&5
+-$as_echo "${with_giflib}" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${with_giflib}" >&5
++printf "%s\n" "${with_giflib}" >&6; }
+ 
+   if test "x${with_giflib}" = "xbundled"; then
+     USE_EXTERNAL_LIBGIF=false
+   elif test "x${with_giflib}" = "xsystem"; then
+-    ac_fn_cxx_check_header_mongrel "$LINENO" "gif_lib.h" "ac_cv_header_gif_lib_h" "$ac_includes_default"
+-if test "x$ac_cv_header_gif_lib_h" = xyes; then :
++    ac_fn_cxx_check_header_compile "$LINENO" "gif_lib.h" "ac_cv_header_gif_lib_h" "$ac_includes_default"
++if test "x$ac_cv_header_gif_lib_h" = xyes
++then :
+ 
+-else
+-   as_fn_error $? "--with-giflib=system specified, but gif_lib.h not found!" "$LINENO" 5
++else case e in #(
++  e)  as_fn_error $? "--with-giflib=system specified, but gif_lib.h not found!" "$LINENO" 5 ;;
++esac
+ fi
+ 
+-
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DGifGetCode in -lgif" >&5
+-$as_echo_n "checking for DGifGetCode in -lgif... " >&6; }
+-if ${ac_cv_lib_gif_DGifGetCode+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for DGifGetCode in -lgif" >&5
++printf %s "checking for DGifGetCode in -lgif... " >&6; }
++if test ${ac_cv_lib_gif_DGifGetCode+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_check_lib_save_LIBS=$LIBS
+ LIBS="-lgif  $LIBS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-/* Override any GCC internal prototype to avoid an error.
+-   Use char because int might match the return type of a GCC
+-   builtin and then its argument prototype would still apply.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-char DGifGetCode ();
++namespace conftest {
++  extern "C" int DGifGetCode ();
++}
+ int
+-main ()
++main (void)
+ {
+-return DGifGetCode ();
++return conftest::DGifGetCode ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   ac_cv_lib_gif_DGifGetCode=yes
+-else
+-  ac_cv_lib_gif_DGifGetCode=no
++else case e in #(
++  e) ac_cv_lib_gif_DGifGetCode=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++LIBS=$ac_check_lib_save_LIBS ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gif_DGifGetCode" >&5
+-$as_echo "$ac_cv_lib_gif_DGifGetCode" >&6; }
+-if test "x$ac_cv_lib_gif_DGifGetCode" = xyes; then :
+-  cat >>confdefs.h <<_ACEOF
+-#define HAVE_LIBGIF 1
+-_ACEOF
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gif_DGifGetCode" >&5
++printf "%s\n" "$ac_cv_lib_gif_DGifGetCode" >&6; }
++if test "x$ac_cv_lib_gif_DGifGetCode" = xyes
++then :
++  printf "%s\n" "#define HAVE_LIBGIF 1" >>confdefs.h
+ 
+   LIBS="-lgif $LIBS"
+ 
+-else
+-   as_fn_error $? "--with-giflib=system specified, but no giflib found!" "$LINENO" 5
++else case e in #(
++  e)  as_fn_error $? "--with-giflib=system specified, but no giflib found!" "$LINENO" 5 ;;
++esac
+ fi
+ 
+ 
+@@ -46419,56 +49087,59 @@ fi
+ 
+ 
+ # Check whether --with-zlib was given.
+-if test "${with_zlib+set}" = set; then :
++if test ${with_zlib+y}
++then :
+   withval=$with_zlib;
+ fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for compress in -lz" >&5
+-$as_echo_n "checking for compress in -lz... " >&6; }
+-if ${ac_cv_lib_z_compress+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for compress in -lz" >&5
++printf %s "checking for compress in -lz... " >&6; }
++if test ${ac_cv_lib_z_compress+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_check_lib_save_LIBS=$LIBS
+ LIBS="-lz  $LIBS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-/* Override any GCC internal prototype to avoid an error.
+-   Use char because int might match the return type of a GCC
+-   builtin and then its argument prototype would still apply.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-char compress ();
++namespace conftest {
++  extern "C" int compress ();
++}
+ int
+-main ()
++main (void)
+ {
+-return compress ();
++return conftest::compress ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   ac_cv_lib_z_compress=yes
+-else
+-  ac_cv_lib_z_compress=no
++else case e in #(
++  e) ac_cv_lib_z_compress=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++LIBS=$ac_check_lib_save_LIBS ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_compress" >&5
+-$as_echo "$ac_cv_lib_z_compress" >&6; }
+-if test "x$ac_cv_lib_z_compress" = xyes; then :
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_compress" >&5
++printf "%s\n" "$ac_cv_lib_z_compress" >&6; }
++if test "x$ac_cv_lib_z_compress" = xyes
++then :
+    ZLIB_FOUND=yes
+-else
+-   ZLIB_FOUND=no
++else case e in #(
++  e)  ZLIB_FOUND=no  ;;
++esac
+ fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for which zlib to use" >&5
+-$as_echo_n "checking for which zlib to use... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for which zlib to use" >&5
++printf %s "checking for which zlib to use... " >&6; }
+ 
+   DEFAULT_ZLIB=bundled
+   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
+@@ -46494,16 +49165,16 @@ $as_echo_n "checking for which zlib to use... " >&6; }
+ 
+   if test "x${with_zlib}" = "xbundled"; then
+     USE_EXTERNAL_LIBZ=false
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: bundled" >&5
+-$as_echo "bundled" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: bundled" >&5
++printf "%s\n" "bundled" >&6; }
+   elif test "x${with_zlib}" = "xsystem"; then
+     if test "x${ZLIB_FOUND}" = "xyes"; then
+       USE_EXTERNAL_LIBZ=true
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: system" >&5
+-$as_echo "system" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: system" >&5
++printf "%s\n" "system" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: system not found" >&5
+-$as_echo "system not found" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: system not found" >&5
++printf "%s\n" "system not found" >&6; }
+       as_fn_error $? "--with-zlib=system specified, but no zlib found!" "$LINENO" 5
+     fi
+   else
+@@ -46526,23 +49197,25 @@ $as_echo "system not found" >&6; }
+ /* end confdefs.h.  */
+ #include <time.h>
+ int
+-main ()
++main (void)
+ {
+ return (int)altzone;
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   has_altzone=yes
+-else
+-  has_altzone=no
++else case e in #(
++  e) has_altzone=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+   if test "x$has_altzone" = xyes; then
+ 
+-$as_echo "#define HAVE_ALTZONE 1" >>confdefs.h
++printf "%s\n" "#define HAVE_ALTZONE 1" >>confdefs.h
+ 
+   fi
+ 
+@@ -46551,55 +49224,55 @@ $as_echo "#define HAVE_ALTZONE 1" >>confdefs.h
+   # Check the maths library
+   #
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cos in -lm" >&5
+-$as_echo_n "checking for cos in -lm... " >&6; }
+-if ${ac_cv_lib_m_cos+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for cos in -lm" >&5
++printf %s "checking for cos in -lm... " >&6; }
++if test ${ac_cv_lib_m_cos+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_check_lib_save_LIBS=$LIBS
+ LIBS="-lm  $LIBS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-/* Override any GCC internal prototype to avoid an error.
+-   Use char because int might match the return type of a GCC
+-   builtin and then its argument prototype would still apply.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-char cos ();
++namespace conftest {
++  extern "C" int cos ();
++}
+ int
+-main ()
++main (void)
+ {
+-return cos ();
++return conftest::cos ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   ac_cv_lib_m_cos=yes
+-else
+-  ac_cv_lib_m_cos=no
++else case e in #(
++  e) ac_cv_lib_m_cos=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++LIBS=$ac_check_lib_save_LIBS ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_cos" >&5
+-$as_echo "$ac_cv_lib_m_cos" >&6; }
+-if test "x$ac_cv_lib_m_cos" = xyes; then :
+-  cat >>confdefs.h <<_ACEOF
+-#define HAVE_LIBM 1
+-_ACEOF
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_cos" >&5
++printf "%s\n" "$ac_cv_lib_m_cos" >&6; }
++if test "x$ac_cv_lib_m_cos" = xyes
++then :
++  printf "%s\n" "#define HAVE_LIBM 1" >>confdefs.h
+ 
+   LIBS="-lm $LIBS"
+ 
+-else
+-
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Maths library was not found" >&5
+-$as_echo "$as_me: Maths library was not found" >&6;}
+-
++else case e in #(
++  e)
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Maths library was not found" >&5
++printf "%s\n" "$as_me: Maths library was not found" >&6;}
+ 
++   ;;
++esac
+ fi
+ 
+ 
+@@ -46610,46 +49283,45 @@ fi
+ 
+   save_LIBS="$LIBS"
+   LIBS=""
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+-$as_echo_n "checking for dlopen in -ldl... " >&6; }
+-if ${ac_cv_lib_dl_dlopen+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  ac_check_lib_save_LIBS=$LIBS
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
++printf %s "checking for dlopen in -ldl... " >&6; }
++if test ${ac_cv_lib_dl_dlopen+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) ac_check_lib_save_LIBS=$LIBS
+ LIBS="-ldl  $LIBS"
+ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+-/* Override any GCC internal prototype to avoid an error.
+-   Use char because int might match the return type of a GCC
+-   builtin and then its argument prototype would still apply.  */
+-#ifdef __cplusplus
+-extern "C"
+-#endif
+-char dlopen ();
++namespace conftest {
++  extern "C" int dlopen ();
++}
+ int
+-main ()
++main (void)
+ {
+-return dlopen ();
++return conftest::dlopen ();
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   ac_cv_lib_dl_dlopen=yes
+-else
+-  ac_cv_lib_dl_dlopen=no
++else case e in #(
++  e) ac_cv_lib_dl_dlopen=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+-LIBS=$ac_check_lib_save_LIBS
++LIBS=$ac_check_lib_save_LIBS ;;
++esac
+ fi
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+-$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
+-if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
+-  cat >>confdefs.h <<_ACEOF
+-#define HAVE_LIBDL 1
+-_ACEOF
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
++printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; }
++if test "x$ac_cv_lib_dl_dlopen" = xyes
++then :
++  printf "%s\n" "#define HAVE_LIBDL 1" >>confdefs.h
+ 
+   LIBS="-ldl $LIBS"
+ 
+@@ -46667,23 +49339,25 @@ fi
+   #
+ 
+ # Check whether --with-stdc++lib was given.
+-if test "${with_stdc__lib+set}" = set; then :
++if test ${with_stdc__lib+y}
++then :
+   withval=$with_stdc__lib;
+         if test "x$with_stdc__lib" != xdynamic && test "x$with_stdc__lib" != xstatic \
+                 && test "x$with_stdc__lib" != xdefault; then
+           as_fn_error $? "Bad parameter value --with-stdc++lib=$with_stdc__lib!" "$LINENO" 5
+         fi
+ 
+-else
+-  with_stdc__lib=default
+-
++else case e in #(
++  e) with_stdc__lib=default
++   ;;
++esac
+ fi
+ 
+ 
+   if test "x$OPENJDK_TARGET_OS" = xlinux; then
+     # Test if -lstdc++ works.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if dynamic link of stdc++ is possible" >&5
+-$as_echo_n "checking if dynamic link of stdc++ is possible... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if dynamic link of stdc++ is possible" >&5
++printf %s "checking if dynamic link of stdc++ is possible... " >&6; }
+     ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+@@ -46696,19 +49370,21 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   has_dynamic_libstdcxx=yes
+-else
+-  has_dynamic_libstdcxx=no
++else case e in #(
++  e) has_dynamic_libstdcxx=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+     CXXFLAGS="$OLD_CXXFLAGS"
+     ac_ext=cpp
+@@ -46717,12 +49393,12 @@ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_dynamic_libstdcxx" >&5
+-$as_echo "$has_dynamic_libstdcxx" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $has_dynamic_libstdcxx" >&5
++printf "%s\n" "$has_dynamic_libstdcxx" >&6; }
+ 
+     # Test if stdc++ can be linked statically.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if static link of stdc++ is possible" >&5
+-$as_echo_n "checking if static link of stdc++ is possible... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if static link of stdc++ is possible" >&5
++printf %s "checking if static link of stdc++ is possible... " >&6; }
+     STATIC_STDCXX_FLAGS="-Wl,-Bstatic -lstdc++ -lgcc -Wl,-Bdynamic"
+     ac_ext=cpp
+ ac_cpp='$CXXCPP $CPPFLAGS'
+@@ -46738,19 +49414,21 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ return 0;
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_link "$LINENO"; then :
++if ac_fn_cxx_try_link "$LINENO"
++then :
+   has_static_libstdcxx=yes
+-else
+-  has_static_libstdcxx=no
++else case e in #(
++  e) has_static_libstdcxx=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext \
++rm -f core conftest.err conftest.$ac_objext conftest.beam \
+     conftest$ac_exeext conftest.$ac_ext
+     LIBS="$OLD_LIBS"
+     CXX="$OLD_CXX"
+@@ -46760,8 +49438,8 @@ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+ 
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_static_libstdcxx" >&5
+-$as_echo "$has_static_libstdcxx" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $has_static_libstdcxx" >&5
++printf "%s\n" "$has_static_libstdcxx" >&6; }
+ 
+     if test "x$has_static_libstdcxx" = xno && test "x$has_dynamic_libstdcxx" = xno; then
+       as_fn_error $? "Cannot link to stdc++, neither dynamically nor statically!" "$LINENO" 5
+@@ -46775,22 +49453,22 @@ $as_echo "$has_static_libstdcxx" >&6; }
+       as_fn_error $? "Dynamic linking of libstdc++ was not possible!" "$LINENO" 5
+     fi
+ 
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to link with libstdc++" >&5
+-$as_echo_n "checking how to link with libstdc++... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libstdc++" >&5
++printf %s "checking how to link with libstdc++... " >&6; }
+     # If dynamic was requested, it's available since it would fail above otherwise.
+     # If dynamic wasn't requested, go with static unless it isn't available.
+     if test "x$with_stdc__lib" = xdynamic || test "x$has_static_libstdcxx" = xno || test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
+       LIBCXX="$LIBCXX -lstdc++"
+       LDCXX="$CXX"
+       STATIC_CXX_SETTING="STATIC_CXX=false"
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: dynamic" >&5
+-$as_echo "dynamic" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: dynamic" >&5
++printf "%s\n" "dynamic" >&6; }
+     else
+       LIBCXX="$LIBCXX $STATIC_STDCXX_FLAGS"
+       LDCXX="$CC"
+       STATIC_CXX_SETTING="STATIC_CXX=true"
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: static" >&5
+-$as_echo "static" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: static" >&5
++printf "%s\n" "static" >&6; }
+     fi
+   fi
+ 
+@@ -46799,17 +49477,17 @@ $as_echo "static" >&6; }
+     # Figure out LIBFFI_CFLAGS and LIBFFI_LIBS
+ 
+ pkg_failed=no
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIBFFI" >&5
+-$as_echo_n "checking for LIBFFI... " >&6; }
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for LIBFFI" >&5
++printf %s "checking for LIBFFI... " >&6; }
+ 
+ if test -n "$LIBFFI_CFLAGS"; then
+     pkg_cv_LIBFFI_CFLAGS="$LIBFFI_CFLAGS"
+  elif test -n "$PKG_CONFIG"; then
+     if test -n "$PKG_CONFIG" && \
+-    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libffi\""; } >&5
++    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libffi\""; } >&5
+   ($PKG_CONFIG --exists --print-errors "libffi") 2>&5
+   ac_status=$?
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; }; then
+   pkg_cv_LIBFFI_CFLAGS=`$PKG_CONFIG --cflags "libffi" 2>/dev/null`
+ else
+@@ -46822,10 +49500,10 @@ if test -n "$LIBFFI_LIBS"; then
+     pkg_cv_LIBFFI_LIBS="$LIBFFI_LIBS"
+  elif test -n "$PKG_CONFIG"; then
+     if test -n "$PKG_CONFIG" && \
+-    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libffi\""; } >&5
++    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libffi\""; } >&5
+   ($PKG_CONFIG --exists --print-errors "libffi") 2>&5
+   ac_status=$?
+-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
++  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+   test $ac_status = 0; }; then
+   pkg_cv_LIBFFI_LIBS=`$PKG_CONFIG --libs "libffi" 2>/dev/null`
+ else
+@@ -46864,8 +49542,8 @@ and LIBFFI_LIBS to avoid the need to call pkg-config.
+ See the pkg-config man page for more details.
+ " "$LINENO" 5
+ elif test $pkg_failed = untried; then
+-	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
++	{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
++printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
+ as_fn_error $? "The pkg-config script could not be found or is too old.  Make sure it
+ is in your PATH or set the PKG_CONFIG environment variable to the full
+ path to pkg-config.
+@@ -46875,12 +49553,12 @@ and LIBFFI_LIBS to avoid the need to call pkg-config.
+ See the pkg-config man page for more details.
+ 
+ To get pkg-config, see <http://pkg-config.freedesktop.org/>.
+-See \`config.log' for more details" "$LINENO" 5; }
++See 'config.log' for more details" "$LINENO" 5; }
+ else
+ 	LIBFFI_CFLAGS=$pkg_cv_LIBFFI_CFLAGS
+ 	LIBFFI_LIBS=$pkg_cv_LIBFFI_LIBS
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+ 	:
+ fi
+ 
+@@ -46889,38 +49567,44 @@ fi
+   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
+     # Extract the first word of "llvm-config", so it can be a program name with args.
+ set dummy llvm-config; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_prog_LLVM_CONFIG+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  if test -n "$LLVM_CONFIG"; then
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_prog_LLVM_CONFIG+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) if test -n "$LLVM_CONFIG"; then
+   ac_cv_prog_LLVM_CONFIG="$LLVM_CONFIG" # Let the user override the test.
+ else
+ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
+     ac_cv_prog_LLVM_CONFIG="llvm-config"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+   done
+ IFS=$as_save_IFS
+ 
+-fi
++fi ;;
++esac
+ fi
+ LLVM_CONFIG=$ac_cv_prog_LLVM_CONFIG
+ if test -n "$LLVM_CONFIG"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LLVM_CONFIG" >&5
+-$as_echo "$LLVM_CONFIG" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LLVM_CONFIG" >&5
++printf "%s\n" "$LLVM_CONFIG" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -46990,7 +49674,8 @@ fi
+ 
+ 
+ # Check whether --with-msvcr-dll was given.
+-if test "${with_msvcr_dll+set}" = set; then :
++if test ${with_msvcr_dll+y}
++then :
+   withval=$with_msvcr_dll;
+ fi
+ 
+@@ -47002,12 +49687,12 @@ fi
+   POSSIBLE_MSVC_DLL="$with_msvcr_dll"
+   METHOD="--with-msvcr-dll"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -47025,8 +49710,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -47048,8 +49733,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -47097,8 +49782,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -47135,8 +49820,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -47147,8 +49832,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -47161,15 +49846,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -47183,12 +49868,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$DEVKIT_MSVCR_DLL"
+   METHOD="devkit"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -47206,8 +49891,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -47229,8 +49914,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -47278,8 +49963,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -47316,8 +50001,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -47328,8 +50013,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -47342,15 +50027,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -47386,8 +50071,8 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of CYGWIN_VC_INSTALL_DIR" "$LINENO" 5
+   fi
+ 
+@@ -47435,8 +50120,8 @@ $as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\"
+ 
+   if test "x$path" != "x$new_path"; then
+     CYGWIN_VC_INSTALL_DIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -47473,8 +50158,8 @@ $as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     CYGWIN_VC_INSTALL_DIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -47485,8 +50170,8 @@ $as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
+     path="$CYGWIN_VC_INSTALL_DIR"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -47522,12 +50207,12 @@ $as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\"
+   POSSIBLE_MSVC_DLL="$possible_msvc_dll"
+   METHOD="well-known location in VCINSTALLDIR"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -47545,8 +50230,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -47568,8 +50253,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -47617,8 +50302,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -47655,8 +50340,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -47667,8 +50352,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -47681,15 +50366,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -47705,12 +50390,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
+   METHOD="well-known location in Boot JDK"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -47728,8 +50413,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -47751,8 +50436,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -47800,8 +50485,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -47838,8 +50523,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -47850,8 +50535,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -47864,15 +50549,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -47897,12 +50582,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
+   METHOD="well-known location in SYSTEMROOT"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -47920,8 +50605,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -47943,8 +50628,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -47992,8 +50677,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -48030,8 +50715,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -48042,8 +50727,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -48056,15 +50741,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -48096,12 +50781,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
+   METHOD="search of VS100COMNTOOLS"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -48119,8 +50804,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -48142,8 +50827,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -48191,8 +50876,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -48229,8 +50914,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -48241,8 +50926,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -48255,15 +50940,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -48292,12 +50977,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
+   METHOD="search of VCINSTALLDIR"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -48315,8 +51000,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -48338,8 +51023,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -48387,8 +51072,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -48425,8 +51110,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -48437,8 +51122,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -48451,15 +51136,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -48467,10 +51152,10 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   fi
+ 
+   if test "x$MSVC_DLL" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+     as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
+   fi
+ 
+@@ -48480,7 +51165,8 @@ $as_echo "no" >&6; }
+ 
+ 
+ # Check whether --with-msvcp-dll was given.
+-if test "${with_msvcp_dll+set}" = set; then :
++if test ${with_msvcp_dll+y}
++then :
+   withval=$with_msvcp_dll;
+ fi
+ 
+@@ -48493,12 +51179,12 @@ fi
+   POSSIBLE_MSVC_DLL="$with_msvcp_dll"
+   METHOD="--with-msvcp-dll"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -48516,8 +51202,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -48539,8 +51225,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -48588,8 +51274,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -48626,8 +51312,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -48638,8 +51324,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -48652,15 +51338,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -48674,12 +51360,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$DEVKIT_MSVCP_DLL"
+   METHOD="devkit"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -48697,8 +51383,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -48720,8 +51406,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -48769,8 +51455,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -48807,8 +51493,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -48819,8 +51505,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -48833,15 +51519,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -48877,8 +51563,8 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of CYGWIN_VC_INSTALL_DIR" "$LINENO" 5
+   fi
+ 
+@@ -48926,8 +51612,8 @@ $as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\"
+ 
+   if test "x$path" != "x$new_path"; then
+     CYGWIN_VC_INSTALL_DIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -48964,8 +51650,8 @@ $as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     CYGWIN_VC_INSTALL_DIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -48976,8 +51662,8 @@ $as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
+     path="$CYGWIN_VC_INSTALL_DIR"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -49013,12 +51699,12 @@ $as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\"
+   POSSIBLE_MSVC_DLL="$possible_msvc_dll"
+   METHOD="well-known location in VCINSTALLDIR"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -49036,8 +51722,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -49059,8 +51745,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -49108,8 +51794,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -49146,8 +51832,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -49158,8 +51844,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -49172,15 +51858,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -49196,12 +51882,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
+   METHOD="well-known location in Boot JDK"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -49219,8 +51905,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -49242,8 +51928,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -49291,8 +51977,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -49329,8 +52015,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -49341,8 +52027,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -49355,15 +52041,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -49388,12 +52074,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
+   METHOD="well-known location in SYSTEMROOT"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -49411,8 +52097,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -49434,8 +52120,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -49483,8 +52169,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -49521,8 +52207,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -49533,8 +52219,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -49547,15 +52233,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -49587,12 +52273,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
+   METHOD="search of VS100COMNTOOLS"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -49610,8 +52296,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -49633,8 +52319,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -49682,8 +52368,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -49720,8 +52406,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -49732,8 +52418,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -49746,15 +52432,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -49783,12 +52469,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
+   METHOD="search of VCINSTALLDIR"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -49806,8 +52492,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -49829,8 +52515,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -49878,8 +52564,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -49916,8 +52602,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -49928,8 +52614,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -49942,15 +52628,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -49958,10 +52644,10 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   fi
+ 
+   if test "x$MSVC_DLL" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+     as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
+   fi
+ 
+@@ -49972,7 +52658,8 @@ $as_echo "no" >&6; }
+ 
+ 
+ # Check whether --with-vcruntime-1-dll was given.
+-if test "${with_vcruntime_1_dll+set}" = set; then :
++if test ${with_vcruntime_1_dll+y}
++then :
+   withval=$with_vcruntime_1_dll;
+ fi
+ 
+@@ -49985,12 +52672,12 @@ fi
+   POSSIBLE_MSVC_DLL="$with_vcruntime_1_dll"
+   METHOD="--with-vcruntime-1-dll"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -50008,8 +52695,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -50031,8 +52718,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -50080,8 +52767,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -50118,8 +52805,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -50130,8 +52817,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -50144,15 +52831,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -50166,12 +52853,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$DEVKIT_VCRUNTIME_1_DLL"
+   METHOD="devkit"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -50189,8 +52876,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -50212,8 +52899,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -50261,8 +52948,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -50299,8 +52986,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -50311,8 +52998,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -50325,15 +53012,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -50369,8 +53056,8 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of CYGWIN_VC_INSTALL_DIR" "$LINENO" 5
+   fi
+ 
+@@ -50418,8 +53105,8 @@ $as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\"
+ 
+   if test "x$path" != "x$new_path"; then
+     CYGWIN_VC_INSTALL_DIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -50456,8 +53143,8 @@ $as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     CYGWIN_VC_INSTALL_DIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -50468,8 +53155,8 @@ $as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
+     path="$CYGWIN_VC_INSTALL_DIR"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -50505,12 +53192,12 @@ $as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\"
+   POSSIBLE_MSVC_DLL="$possible_msvc_dll"
+   METHOD="well-known location in VCINSTALLDIR"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -50528,8 +53215,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -50551,8 +53238,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -50600,8 +53287,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -50638,8 +53325,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -50650,8 +53337,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -50664,15 +53351,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -50688,12 +53375,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
+   METHOD="well-known location in Boot JDK"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -50711,8 +53398,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -50734,8 +53421,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -50783,8 +53470,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -50821,8 +53508,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -50833,8 +53520,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -50847,15 +53534,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -50880,12 +53567,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
+   METHOD="well-known location in SYSTEMROOT"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -50903,8 +53590,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -50926,8 +53613,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -50975,8 +53662,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -51013,8 +53700,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -51025,8 +53712,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -51039,15 +53726,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -51079,12 +53766,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
+   METHOD="search of VS100COMNTOOLS"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -51102,8 +53789,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -51125,8 +53812,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -51174,8 +53861,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -51212,8 +53899,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -51224,8 +53911,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -51238,15 +53925,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -51275,12 +53962,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
+   METHOD="search of VCINSTALLDIR"
+   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
+-$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
++printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
+ 
+     # Need to check if the found msvcr is correct architecture
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
+-$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
++printf %s "checking found $DLL_NAME architecture... " >&6; }
+     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
+     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
+@@ -51298,8 +53985,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
+       fi
+     fi
+     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+-$as_echo "ok" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
++printf "%s\n" "ok" >&6; }
+       MSVC_DLL="$POSSIBLE_MSVC_DLL"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -51321,8 +54008,8 @@ $as_echo "ok" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
+   fi
+ 
+@@ -51370,8 +54057,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -51408,8 +54095,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     MSVC_DLL="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -51420,8 +54107,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
+     path="$MSVC_DLL"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -51434,15 +54121,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
+     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
+   fi
+ 
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
+-$as_echo "$MSVC_DLL" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
++printf "%s\n" "$MSVC_DLL" >&6; }
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
+-$as_echo "incorrect, ignoring" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
+-$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
++printf "%s\n" "incorrect, ignoring" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
++printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
+     fi
+   fi
+ 
+@@ -51450,10 +54137,10 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
+   fi
+ 
+   if test "x$MSVC_DLL" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
+-$as_echo_n "checking for $DLL_NAME... " >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
++printf %s "checking for $DLL_NAME... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+     as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
+   fi
+ 
+@@ -51464,22 +54151,23 @@ $as_echo "no" >&6; }
+ 
+ 
+ # Check whether --with-ucrt-dll-dir was given.
+-if test "${with_ucrt_dll_dir+set}" = set; then :
++if test ${with_ucrt_dll_dir+y}
++then :
+   withval=$with_ucrt_dll_dir;
+ fi
+ 
+ 
+   if test "x$USE_UCRT" = "xtrue"; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UCRT DLL dir" >&5
+-$as_echo_n "checking for UCRT DLL dir... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for UCRT DLL dir" >&5
++printf %s "checking for UCRT DLL dir... " >&6; }
+     if test "x$with_ucrt_dll_dir" != x; then
+       if test -z "$(ls -d "$with_ucrt_dll_dir/"*.dll 2> /dev/null)"; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+         as_fn_error $? "Could not find any dlls in $with_ucrt_dll_dir" "$LINENO" 5
+       else
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_ucrt_dll_dir" >&5
+-$as_echo "$with_ucrt_dll_dir" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_ucrt_dll_dir" >&5
++printf "%s\n" "$with_ucrt_dll_dir" >&6; }
+         UCRT_DLL_DIR="$with_ucrt_dll_dir"
+ 
+   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
+@@ -51501,8 +54189,8 @@ $as_echo "$with_ucrt_dll_dir" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of UCRT_DLL_DIR" "$LINENO" 5
+   fi
+ 
+@@ -51550,8 +54238,8 @@ $as_echo "$as_me: The path of UCRT_DLL_DIR, which resolves as \"$path\", is inva
+ 
+   if test "x$path" != "x$new_path"; then
+     UCRT_DLL_DIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -51588,8 +54276,8 @@ $as_echo "$as_me: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     UCRT_DLL_DIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -51600,8 +54288,8 @@ $as_echo "$as_me: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&6;}
+     path="$UCRT_DLL_DIR"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -51617,8 +54305,8 @@ $as_echo "$as_me: The path of UCRT_DLL_DIR, which resolves as \"$path\", is inva
+       fi
+     elif test "x$DEVKIT_UCRT_DLL_DIR" != "x"; then
+       UCRT_DLL_DIR="$DEVKIT_UCRT_DLL_DIR"
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UCRT_DLL_DIR" >&5
+-$as_echo "$UCRT_DLL_DIR" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UCRT_DLL_DIR" >&5
++printf "%s\n" "$UCRT_DLL_DIR" >&6; }
+     else
+       CYGWIN_WINDOWSSDKDIR="${WINDOWSSDKDIR}"
+ 
+@@ -51641,8 +54329,8 @@ $as_echo "$UCRT_DLL_DIR" >&6; }
+   # It is also a way to make sure we got the proper file name for the real test later on.
+   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
+   if test "x$test_shortpath" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&6;}
+     as_fn_error $? "Cannot locate the the path of CYGWIN_WINDOWSSDKDIR" "$LINENO" 5
+   fi
+ 
+@@ -51690,8 +54378,8 @@ $as_echo "$as_me: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\",
+ 
+   if test "x$path" != "x$new_path"; then
+     CYGWIN_WINDOWSSDKDIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&6;}
+   fi
+ 
+   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
+@@ -51728,8 +54416,8 @@ $as_echo "$as_me: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&6;}
+ 
+   if test "x$path" != "x$new_path"; then
+     CYGWIN_WINDOWSSDKDIR="$new_path"
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&5
+-$as_echo "$as_me: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&5
++printf "%s\n" "$as_me: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&6;}
+   fi
+ 
+   # Save the first 10 bytes of this path to the storage, so fixpath can work.
+@@ -51740,8 +54428,8 @@ $as_echo "$as_me: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&6;}
+     path="$CYGWIN_WINDOWSSDKDIR"
+     has_space=`$ECHO "$path" | $GREP " "`
+     if test "x$has_space" != x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&5
+-$as_echo "$as_me: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&5
++printf "%s\n" "$as_me: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&6;}
+       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
+     fi
+ 
+@@ -51765,16 +54453,16 @@ $as_echo "$as_me: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\",
+             2> /dev/null | $SORT -d | $HEAD -n1`"
+         if test -z "$UCRT_DLL_DIR" \
+             || test -z "$(ls -d "$UCRT_DLL_DIR/"*.dll 2> /dev/null)"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+           as_fn_error $? "Could not find any dlls in $UCRT_DLL_DIR" "$LINENO" 5
+         else
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UCRT_DLL_DIR" >&5
+-$as_echo "$UCRT_DLL_DIR" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UCRT_DLL_DIR" >&5
++printf "%s\n" "$UCRT_DLL_DIR" >&6; }
+         fi
+       else
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UCRT_DLL_DIR" >&5
+-$as_echo "$UCRT_DLL_DIR" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UCRT_DLL_DIR" >&5
++printf "%s\n" "$UCRT_DLL_DIR" >&6; }
+       fi
+     fi
+   else
+@@ -51785,27 +54473,30 @@ $as_echo "$UCRT_DLL_DIR" >&6; }
+ 
+ 
+ # Check whether --with-dxsdk was given.
+-if test "${with_dxsdk+set}" = set; then :
+-  withval=$with_dxsdk; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&5
+-$as_echo "$as_me: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&2;}
++if test ${with_dxsdk+y}
++then :
++  withval=$with_dxsdk; { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&5
++printf "%s\n" "$as_me: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&2;}
+ fi
+ 
+ 
+ 
+ 
+ # Check whether --with-dxsdk-lib was given.
+-if test "${with_dxsdk_lib+set}" = set; then :
+-  withval=$with_dxsdk_lib; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&5
+-$as_echo "$as_me: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&2;}
++if test ${with_dxsdk_lib+y}
++then :
++  withval=$with_dxsdk_lib; { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&5
++printf "%s\n" "$as_me: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&2;}
+ fi
+ 
+ 
+ 
+ 
+ # Check whether --with-dxsdk-include was given.
+-if test "${with_dxsdk_include+set}" = set; then :
+-  withval=$with_dxsdk_include; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&5
+-$as_echo "$as_me: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&2;}
++if test ${with_dxsdk_include+y}
++then :
++  withval=$with_dxsdk_include; { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&5
++printf "%s\n" "$as_me: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&2;}
+ fi
+ 
+ 
+@@ -51830,17 +54521,17 @@ fi
+ 
+ 
+ 
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if elliptic curve crypto implementation is present" >&5
+-$as_echo_n "checking if elliptic curve crypto implementation is present... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if elliptic curve crypto implementation is present" >&5
++printf %s "checking if elliptic curve crypto implementation is present... " >&6; }
+ 
+     if test -d "${SRC_ROOT}/jdk/src/share/native/sun/security/ec/impl"; then
+       ENABLE_INTREE_EC=yes
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+     else
+       ENABLE_INTREE_EC=no
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+     fi
+ 
+ 
+@@ -51857,15 +54548,16 @@ $as_echo "no" >&6; }
+   # How many cores do we have on this build system?
+ 
+ # Check whether --with-num-cores was given.
+-if test "${with_num_cores+set}" = set; then :
++if test ${with_num_cores+y}
++then :
+   withval=$with_num_cores;
+ fi
+ 
+   if test "x$with_num_cores" = x; then
+     # The number of cores were not specified, try to probe them.
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for number of cores" >&5
+-$as_echo_n "checking for number of cores... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for number of cores" >&5
++printf %s "checking for number of cores... " >&6; }
+   NUM_CORES=1
+   FOUND_CORES=no
+ 
+@@ -51894,13 +54586,13 @@ $as_echo_n "checking for number of cores... " >&6; }
+   fi
+ 
+   if test "x$FOUND_CORES" = xyes; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NUM_CORES" >&5
+-$as_echo "$NUM_CORES" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NUM_CORES" >&5
++printf "%s\n" "$NUM_CORES" >&6; }
+   else
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not detect number of cores, defaulting to 1" >&5
+-$as_echo "could not detect number of cores, defaulting to 1" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This will disable all parallelism from build!" >&5
+-$as_echo "$as_me: WARNING: This will disable all parallelism from build!" >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: could not detect number of cores, defaulting to 1" >&5
++printf "%s\n" "could not detect number of cores, defaulting to 1" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: This will disable all parallelism from build!" >&5
++printf "%s\n" "$as_me: WARNING: This will disable all parallelism from build!" >&2;}
+   fi
+ 
+   else
+@@ -51912,15 +54604,16 @@ $as_echo "$as_me: WARNING: This will disable all parallelism from build!" >&2;}
+   # How much memory do we have on this build system?
+ 
+ # Check whether --with-memory-size was given.
+-if test "${with_memory_size+set}" = set; then :
++if test ${with_memory_size+y}
++then :
+   withval=$with_memory_size;
+ fi
+ 
+   if test "x$with_memory_size" = x; then
+     # The memory size was not specified, try to probe it.
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for memory size" >&5
+-$as_echo_n "checking for memory size... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for memory size" >&5
++printf %s "checking for memory size... " >&6; }
+   # Default to 1024 MB
+   MEMORY_SIZE=1024
+   FOUND_MEM=no
+@@ -51947,13 +54640,13 @@ $as_echo_n "checking for memory size... " >&6; }
+   fi
+ 
+   if test "x$FOUND_MEM" = xyes; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MEMORY_SIZE MB" >&5
+-$as_echo "$MEMORY_SIZE MB" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MEMORY_SIZE MB" >&5
++printf "%s\n" "$MEMORY_SIZE MB" >&6; }
+   else
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not detect memory size, defaulting to 1024 MB" >&5
+-$as_echo "could not detect memory size, defaulting to 1024 MB" >&6; }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This might seriously impact build performance!" >&5
+-$as_echo "$as_me: WARNING: This might seriously impact build performance!" >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: could not detect memory size, defaulting to 1024 MB" >&5
++printf "%s\n" "could not detect memory size, defaulting to 1024 MB" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: This might seriously impact build performance!" >&5
++printf "%s\n" "$as_me: WARNING: This might seriously impact build performance!" >&2;}
+   fi
+ 
+   else
+@@ -51966,14 +54659,15 @@ $as_echo "$as_me: WARNING: This might seriously impact build performance!" >&2;}
+   # number of cores, amount of memory and machine architecture.
+ 
+ # Check whether --with-jobs was given.
+-if test "${with_jobs+set}" = set; then :
++if test ${with_jobs+y}
++then :
+   withval=$with_jobs;
+ fi
+ 
+   if test "x$with_jobs" = x; then
+     # Number of jobs was not specified, calculate.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for appropriate number of jobs to run in parallel" >&5
+-$as_echo_n "checking for appropriate number of jobs to run in parallel... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for appropriate number of jobs to run in parallel" >&5
++printf %s "checking for appropriate number of jobs to run in parallel... " >&6; }
+     # Approximate memory in GB, rounding up a bit.
+     memory_gb=`expr $MEMORY_SIZE / 1100`
+     # Pick the lowest of memory in gb and number of cores.
+@@ -51993,8 +54687,8 @@ $as_echo_n "checking for appropriate number of jobs to run in parallel... " >&6;
+     if test "$JOBS" -eq "0"; then
+       JOBS=1
+     fi
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JOBS" >&5
+-$as_echo "$JOBS" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JOBS" >&5
++printf "%s\n" "$JOBS" >&6; }
+   else
+     JOBS=$with_jobs
+   fi
+@@ -52005,7 +54699,8 @@ $as_echo "$JOBS" >&6; }
+ 
+ 
+ # Check whether --with-sjavac-server-java was given.
+-if test "${with_sjavac_server_java+set}" = set; then :
++if test ${with_sjavac_server_java+y}
++then :
+   withval=$with_sjavac_server_java;
+ fi
+ 
+@@ -52198,17 +54893,19 @@ fi
+ 
+   fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use sjavac" >&5
+-$as_echo_n "checking whether to use sjavac... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to use sjavac" >&5
++printf %s "checking whether to use sjavac... " >&6; }
+   # Check whether --enable-sjavac was given.
+-if test "${enable_sjavac+set}" = set; then :
++if test ${enable_sjavac+y}
++then :
+   enableval=$enable_sjavac; ENABLE_SJAVAC="${enableval}"
+-else
+-  ENABLE_SJAVAC='no'
++else case e in #(
++  e) ENABLE_SJAVAC='no' ;;
++esac
+ fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_SJAVAC" >&5
+-$as_echo "$ENABLE_SJAVAC" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ENABLE_SJAVAC" >&5
++printf "%s\n" "$ENABLE_SJAVAC" >&6; }
+ 
+ 
+   if test "x$ENABLE_SJAVAC" = xyes; then
+@@ -52227,10 +54924,12 @@ $as_echo "$ENABLE_SJAVAC" >&6; }
+   # Can the C/C++ compiler use precompiled headers?
+   #
+   # Check whether --enable-precompiled-headers was given.
+-if test "${enable_precompiled_headers+set}" = set; then :
++if test ${enable_precompiled_headers+y}
++then :
+   enableval=$enable_precompiled_headers; ENABLE_PRECOMPH=${enable_precompiled_headers}
+-else
+-  ENABLE_PRECOMPH=yes
++else case e in #(
++  e) ENABLE_PRECOMPH=yes ;;
++esac
+ fi
+ 
+ 
+@@ -52242,17 +54941,17 @@ fi
+   if test "x$ENABLE_PRECOMPH" = xyes; then
+     # Check that the compiler actually supports precomp headers.
+     if test "x$TOOLCHAIN_TYPE" = xgcc; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking that precompiled headers work" >&5
+-$as_echo_n "checking that precompiled headers work... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking that precompiled headers work" >&5
++printf %s "checking that precompiled headers work... " >&6; }
+       echo "int alfa();" > conftest.h
+       $CXX -x c++-header conftest.h -o conftest.hpp.gch 2>&5 >&5
+       if test ! -f conftest.hpp.gch; then
+         USE_PRECOMPILED_HEADER=0
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+       else
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+       fi
+       rm -f conftest.h conftest.hpp.gch
+     fi
+@@ -52264,18 +54963,19 @@ $as_echo "yes" >&6; }
+ # Setup use of ccache, if available
+ 
+   # Check whether --enable-ccache was given.
+-if test "${enable_ccache+set}" = set; then :
++if test ${enable_ccache+y}
++then :
+   enableval=$enable_ccache;
+ fi
+ 
+ 
+   CCACHE=
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking is ccache enabled" >&5
+-$as_echo_n "checking is ccache enabled... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking is ccache enabled" >&5
++printf %s "checking is ccache enabled... " >&6; }
+   ENABLE_CCACHE=$enable_ccache
+   if test "x$enable_ccache" = xyes; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+     OLD_PATH="$PATH"
+     if test "x$TOOLCHAIN_PATH" != x; then
+       PATH=$TOOLCHAIN_PATH:$PATH
+@@ -52292,12 +54992,13 @@ $as_echo "yes" >&6; }
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CCACHE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CCACHE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CCACHE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CCACHE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
+   ;;
+@@ -52306,11 +55007,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CCACHE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -52318,15 +55023,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CCACHE=$ac_cv_path_CCACHE
+ if test -n "$CCACHE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
+-$as_echo "$CCACHE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
++printf "%s\n" "$CCACHE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -52342,20 +55048,21 @@ done
+       # If it failed, the variable was not from the command line. Ignore it,
+       # but warn the user (except for BASH, which is always set by the calling BASH).
+       if test "xCCACHE" != xBASH; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&5
+-$as_echo "$as_me: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&2;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&5
++printf "%s\n" "$as_me: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&2;}
+       fi
+       # Try to locate tool using the code snippet
+       for ac_prog in ccache
+ do
+   # Extract the first word of "$ac_prog", so it can be a program name with args.
+ set dummy $ac_prog; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CCACHE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CCACHE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CCACHE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CCACHE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
+   ;;
+@@ -52364,11 +55071,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CCACHE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -52376,15 +55087,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CCACHE=$ac_cv_path_CCACHE
+ if test -n "$CCACHE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
+-$as_echo "$CCACHE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
++printf "%s\n" "$CCACHE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -52404,16 +55116,17 @@ done
+       tool_basename="${tool_specified##*/}"
+       if test "x$tool_basename" = "x$tool_specified"; then
+         # A command without a complete path is provided, search $PATH.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CCACHE=$tool_basename" >&5
+-$as_echo "$as_me: Will search for user supplied tool CCACHE=$tool_basename" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CCACHE=$tool_basename" >&5
++printf "%s\n" "$as_me: Will search for user supplied tool CCACHE=$tool_basename" >&6;}
+         # Extract the first word of "$tool_basename", so it can be a program name with args.
+ set dummy $tool_basename; ac_word=$2
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+-$as_echo_n "checking for $ac_word... " >&6; }
+-if ${ac_cv_path_CCACHE+:} false; then :
+-  $as_echo_n "(cached) " >&6
+-else
+-  case $CCACHE in
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
++printf %s "checking for $ac_word... " >&6; }
++if test ${ac_cv_path_CCACHE+y}
++then :
++  printf %s "(cached) " >&6
++else case e in #(
++  e) case $CCACHE in
+   [\\/]* | ?:[\\/]*)
+   ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
+   ;;
+@@ -52422,11 +55135,15 @@ else
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
+     for ac_exec_ext in '' $ac_executable_extensions; do
+-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+-    ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
+-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
++  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
++    ac_cv_path_CCACHE="$as_dir$ac_word$ac_exec_ext"
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
+     break 2
+   fi
+ done
+@@ -52434,15 +55151,16 @@ done
+ IFS=$as_save_IFS
+ 
+   ;;
++esac ;;
+ esac
+ fi
+ CCACHE=$ac_cv_path_CCACHE
+ if test -n "$CCACHE"; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
+-$as_echo "$CCACHE" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
++printf "%s\n" "$CCACHE" >&6; }
+ else
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+ fi
+ 
+ 
+@@ -52451,17 +55169,17 @@ fi
+         fi
+       else
+         # Otherwise we believe it is a complete path. Use it as it is.
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CCACHE=$tool_specified" >&5
+-$as_echo "$as_me: Will use user supplied tool CCACHE=$tool_specified" >&6;}
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CCACHE" >&5
+-$as_echo_n "checking for CCACHE... " >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CCACHE=$tool_specified" >&5
++printf "%s\n" "$as_me: Will use user supplied tool CCACHE=$tool_specified" >&6;}
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CCACHE" >&5
++printf %s "checking for CCACHE... " >&6; }
+         if test ! -x "$tool_specified"; then
+-          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
+-$as_echo "not found" >&6; }
++          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
++printf "%s\n" "not found" >&6; }
+           as_fn_error $? "User supplied tool CCACHE=$tool_specified does not exist or is not executable" "$LINENO" 5
+         fi
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
+-$as_echo "$tool_specified" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
++printf "%s\n" "$tool_specified" >&6; }
+       fi
+     fi
+   fi
+@@ -52476,21 +55194,22 @@ $as_echo "$tool_specified" >&6; }
+     CCACHE_STATUS="enabled"
+     PATH="$OLD_PATH"
+   elif test "x$enable_ccache" = xno; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, explicitly disabled" >&5
+-$as_echo "no, explicitly disabled" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, explicitly disabled" >&5
++printf "%s\n" "no, explicitly disabled" >&6; }
+   elif test "x$enable_ccache" = x; then
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+-$as_echo "no" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
++printf "%s\n" "no" >&6; }
+   else
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
+-$as_echo "unknown" >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
++printf "%s\n" "unknown" >&6; }
+     as_fn_error $? "--enable-ccache does not accept any parameters" "$LINENO" 5
+   fi
+ 
+ 
+ 
+ # Check whether --with-ccache-dir was given.
+-if test "${with_ccache_dir+set}" = set; then :
++if test ${with_ccache_dir+y}
++then :
+   withval=$with_ccache_dir;
+ fi
+ 
+@@ -52500,8 +55219,8 @@ fi
+     # with other users. Thus change the umask.
+     SET_CCACHE_DIR="CCACHE_DIR=$with_ccache_dir CCACHE_UMASK=002"
+     if test "x$CCACHE" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-ccache-dir has no meaning when ccache is not enabled" >&5
+-$as_echo "$as_me: WARNING: --with-ccache-dir has no meaning when ccache is not enabled" >&2;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: --with-ccache-dir has no meaning when ccache is not enabled" >&5
++printf "%s\n" "$as_me: WARNING: --with-ccache-dir has no meaning when ccache is not enabled" >&2;}
+     fi
+   fi
+ 
+@@ -52510,45 +55229,47 @@ $as_echo "$as_me: WARNING: --with-ccache-dir has no meaning when ccache is not e
+   if test "x$CCACHE" != x; then
+     # Only use ccache if it is 3.1.4 or later, which supports
+     # precompiled headers.
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if ccache supports precompiled headers" >&5
+-$as_echo_n "checking if ccache supports precompiled headers... " >&6; }
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ccache supports precompiled headers" >&5
++printf %s "checking if ccache supports precompiled headers... " >&6; }
+     HAS_GOOD_CCACHE=`($CCACHE --version | head -n 1 | grep -E 3.1.[456789]) 2> /dev/null`
+     if test "x$HAS_GOOD_CCACHE" = x; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, disabling ccache" >&5
+-$as_echo "no, disabling ccache" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, disabling ccache" >&5
++printf "%s\n" "no, disabling ccache" >&6; }
+       CCACHE=
+       CCACHE_STATUS="disabled"
+     else
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: checking if C-compiler supports ccache precompiled headers" >&5
+-$as_echo_n "checking if C-compiler supports ccache precompiled headers... " >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if C-compiler supports ccache precompiled headers" >&5
++printf %s "checking if C-compiler supports ccache precompiled headers... " >&6; }
+       PUSHED_FLAGS="$CXXFLAGS"
+       CXXFLAGS="-fpch-preprocess $CXXFLAGS"
+       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+ /* end confdefs.h.  */
+ 
+ int
+-main ()
++main (void)
+ {
+ 
+   ;
+   return 0;
+ }
+ _ACEOF
+-if ac_fn_cxx_try_compile "$LINENO"; then :
++if ac_fn_cxx_try_compile "$LINENO"
++then :
+   CC_KNOWS_CCACHE_TRICK=yes
+-else
+-  CC_KNOWS_CCACHE_TRICK=no
++else case e in #(
++  e) CC_KNOWS_CCACHE_TRICK=no ;;
++esac
+ fi
+-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
++rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
+       CXXFLAGS="$PUSHED_FLAGS"
+       if test "x$CC_KNOWS_CCACHE_TRICK" = xyes; then
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+-$as_echo "yes" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
++printf "%s\n" "yes" >&6; }
+       else
+-        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, disabling ccaching of precompiled headers" >&5
+-$as_echo "no, disabling ccaching of precompiled headers" >&6; }
++        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, disabling ccaching of precompiled headers" >&5
++printf "%s\n" "no, disabling ccaching of precompiled headers" >&6; }
+         CCACHE=
+         CCACHE_STATUS="disabled"
+       fi
+@@ -52590,13 +55311,13 @@ $as_echo "no, disabling ccaching of precompiled headers" >&6; }
+   if test "x$CONFIGURE_OVERRIDDEN_VARIABLES" != x; then
+     # Replace the separating ! with spaces before presenting for end user.
+     unknown_variables=${CONFIGURE_OVERRIDDEN_VARIABLES//!/ }
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The following variables might be unknown to configure: $unknown_variables" >&5
+-$as_echo "$as_me: WARNING: The following variables might be unknown to configure: $unknown_variables" >&2;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: The following variables might be unknown to configure: $unknown_variables" >&5
++printf "%s\n" "$as_me: WARNING: The following variables might be unknown to configure: $unknown_variables" >&2;}
+   fi
+ 
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if build directory is on local disk" >&5
+-$as_echo_n "checking if build directory is on local disk... " >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if build directory is on local disk" >&5
++printf %s "checking if build directory is on local disk... " >&6; }
+ 
+   # df -l lists only local disks; if the given directory is not found then
+   # a non-zero exit code is given
+@@ -52621,8 +55342,8 @@ $as_echo_n "checking if build directory is on local disk... " >&6; }
+     fi
+   fi
+ 
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_DIR_IS_LOCAL" >&5
+-$as_echo "$OUTPUT_DIR_IS_LOCAL" >&6; }
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_DIR_IS_LOCAL" >&5
++printf "%s\n" "$OUTPUT_DIR_IS_LOCAL" >&6; }
+ 
+ 
+ 
+@@ -52656,8 +55377,8 @@ cat >confcache <<\_ACEOF
+ # config.status only pays attention to the cache file if you give it
+ # the --recheck option to rerun configure.
+ #
+-# `ac_cv_env_foo' variables (set or unset) will be overridden when
+-# loading this file, other *unset* `ac_cv_foo' will be assigned the
++# 'ac_cv_env_foo' variables (set or unset) will be overridden when
++# loading this file, other *unset* 'ac_cv_foo' will be assigned the
+ # following values.
+ 
+ _ACEOF
+@@ -52673,8 +55394,8 @@ _ACEOF
+     case $ac_val in #(
+     *${as_nl}*)
+       case $ac_var in #(
+-      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+-$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
++      *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
++printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+       esac
+       case $ac_var in #(
+       _ | IFS | as_nl) ;; #(
+@@ -52687,14 +55408,14 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+   (set) 2>&1 |
+     case $as_nl`(ac_space=' '; set) 2>&1` in #(
+     *${as_nl}ac_space=\ *)
+-      # `set' does not quote correctly, so add quotes: double-quote
++      # 'set' does not quote correctly, so add quotes: double-quote
+       # substitution turns \\\\ into \\, and sed turns \\ into \.
+       sed -n \
+ 	"s/'/'\\\\''/g;
+ 	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
+       ;; #(
+     *)
+-      # `set' quotes correctly as required by POSIX, so do not add quotes.
++      # 'set' quotes correctly as required by POSIX, so do not add quotes.
+       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
+       ;;
+     esac |
+@@ -52704,15 +55425,15 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      /^ac_cv_env_/b end
+      t clear
+      :clear
+-     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
++     s/^\([^=]*\)=\(.*[{}].*\)$/test ${\1+y} || &/
+      t end
+      s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
+      :end' >>confcache
+ if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
+   if test -w "$cache_file"; then
+     if test "x$cache_file" != "x/dev/null"; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
+-$as_echo "$as_me: updating cache $cache_file" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
++printf "%s\n" "$as_me: updating cache $cache_file" >&6;}
+       if test ! -f "$cache_file" || test -h "$cache_file"; then
+ 	cat confcache >"$cache_file"
+       else
+@@ -52726,8 +55447,8 @@ $as_echo "$as_me: updating cache $cache_file" >&6;}
+       fi
+     fi
+   else
+-    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
+-$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
++    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
++printf "%s\n" "$as_me: not updating unwritable cache $cache_file" >&6;}
+   fi
+ fi
+ rm -f confcache
+@@ -52744,7 +55465,7 @@ U=
+ for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+   # 1. Remove the extension, and $U if already installed.
+   ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
+-  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
++  ac_i=`printf "%s\n" "$ac_i" | sed "$ac_script"`
+   # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
+   #    will be set to the directory where LIBOBJS objects are built.
+   as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
+@@ -52760,8 +55481,8 @@ LTLIBOBJS=$ac_ltlibobjs
+ ac_write_fail=0
+ ac_clean_files_save=$ac_clean_files
+ ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+-{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
+-$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
++{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
++printf "%s\n" "$as_me: creating $CONFIG_STATUS" >&6;}
+ as_write_fail=0
+ cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
+ #! $SHELL
+@@ -52784,63 +55505,65 @@ cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
+ 
+ # Be more Bourne compatible
+ DUALCASE=1; export DUALCASE # for MKS sh
+-if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
++if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
++then :
+   emulate sh
+   NULLCMD=:
+   # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+   # is contrary to our usage.  Disable this feature.
+   alias -g '${1+"$@"}'='"$@"'
+   setopt NO_GLOB_SUBST
+-else
+-  case `(set -o) 2>/dev/null` in #(
++else case e in #(
++  e) case `(set -o) 2>/dev/null` in #(
+   *posix*) :
+     set -o posix ;; #(
+   *) :
+      ;;
++esac ;;
+ esac
+ fi
+ 
+ 
++
++# Reset variables that may have inherited troublesome values from
++# the environment.
++
++# IFS needs to be set, to space, tab, and newline, in precisely that order.
++# (If _AS_PATH_WALK were called with IFS unset, it would have the
++# side effect of setting IFS to empty, thus disabling word splitting.)
++# Quoting is to prevent editors from complaining about space-tab.
+ as_nl='
+ '
+ export as_nl
+-# Printing a long string crashes Solaris 7 /usr/bin/printf.
+-as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+-as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+-# Prefer a ksh shell builtin over an external printf program on Solaris,
+-# but without wasting forks for bash or zsh.
+-if test -z "$BASH_VERSION$ZSH_VERSION" \
+-    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+-  as_echo='print -r --'
+-  as_echo_n='print -rn --'
+-elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+-  as_echo='printf %s\n'
+-  as_echo_n='printf %s'
+-else
+-  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+-    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+-    as_echo_n='/usr/ucb/echo -n'
+-  else
+-    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
+-    as_echo_n_body='eval
+-      arg=$1;
+-      case $arg in #(
+-      *"$as_nl"*)
+-	expr "X$arg" : "X\\(.*\\)$as_nl";
+-	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
+-      esac;
+-      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
+-    '
+-    export as_echo_n_body
+-    as_echo_n='sh -c $as_echo_n_body as_echo'
+-  fi
+-  export as_echo_body
+-  as_echo='sh -c $as_echo_body as_echo'
+-fi
++IFS=" ""	$as_nl"
++
++PS1='$ '
++PS2='> '
++PS4='+ '
++
++# Ensure predictable behavior from utilities with locale-dependent output.
++LC_ALL=C
++export LC_ALL
++LANGUAGE=C
++export LANGUAGE
++
++# We cannot yet rely on "unset" to work, but we need these variables
++# to be unset--not just set to an empty or harmless value--now, to
++# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh).  This construct
++# also avoids known problems related to "unset" and subshell syntax
++# in other old shells (e.g. bash 2.01 and pdksh 5.2.14).
++for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH
++do eval test \${$as_var+y} \
++  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
++done
++
++# Ensure that fds 0, 1, and 2 are open.
++if (exec 3>&0) 2>/dev/null; then :; else exec 0</dev/null; fi
++if (exec 3>&1) 2>/dev/null; then :; else exec 1>/dev/null; fi
++if (exec 3>&2)            ; then :; else exec 2>/dev/null; fi
+ 
+ # The user is always right.
+-if test "${PATH_SEPARATOR+set}" != set; then
++if ${PATH_SEPARATOR+false} :; then
+   PATH_SEPARATOR=:
+   (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+     (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+@@ -52849,13 +55572,6 @@ if test "${PATH_SEPARATOR+set}" != set; then
+ fi
+ 
+ 
+-# IFS
+-# We need space, tab and new line, in precisely that order.  Quoting is
+-# there to prevent editors from complaining about space-tab.
+-# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+-# splitting by setting IFS to empty value.)
+-IFS=" ""	$as_nl"
+-
+ # Find who we are.  Look in the path if we contain no directory separator.
+ as_myself=
+ case $0 in #((
+@@ -52864,43 +55580,27 @@ case $0 in #((
+ for as_dir in $PATH
+ do
+   IFS=$as_save_IFS
+-  test -z "$as_dir" && as_dir=.
+-    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
++  case $as_dir in #(((
++    '') as_dir=./ ;;
++    */) ;;
++    *) as_dir=$as_dir/ ;;
++  esac
++    test -r "$as_dir$0" && as_myself=$as_dir$0 && break
+   done
+ IFS=$as_save_IFS
+ 
+      ;;
+ esac
+-# We did not find ourselves, most probably we were run as `sh COMMAND'
++# We did not find ourselves, most probably we were run as 'sh COMMAND'
+ # in which case we are not to be found in the path.
+ if test "x$as_myself" = x; then
+   as_myself=$0
+ fi
+ if test ! -f "$as_myself"; then
+-  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
++  printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+   exit 1
+ fi
+ 
+-# Unset variables that we do not need and which cause bugs (e.g. in
+-# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+-# suppresses any "Segmentation fault" message there.  '((' could
+-# trigger a bug in pdksh 5.2.14.
+-for as_var in BASH_ENV ENV MAIL MAILPATH
+-do eval test x\${$as_var+set} = xset \
+-  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+-done
+-PS1='$ '
+-PS2='> '
+-PS4='+ '
+-
+-# NLS nuisances.
+-LC_ALL=C
+-export LC_ALL
+-LANGUAGE=C
+-export LANGUAGE
+-
+-# CDPATH.
+-(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+ 
+ 
+ # as_fn_error STATUS ERROR [LINENO LOG_FD]
+@@ -52913,9 +55613,9 @@ as_fn_error ()
+   as_status=$1; test $as_status -eq 0 && as_status=1
+   if test "$4"; then
+     as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+-    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
++    printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+   fi
+-  $as_echo "$as_me: error: $2" >&2
++  printf "%s\n" "$as_me: error: $2" >&2
+   as_fn_exit $as_status
+ } # as_fn_error
+ 
+@@ -52946,22 +55646,25 @@ as_fn_unset ()
+   { eval $1=; unset $1;}
+ }
+ as_unset=as_fn_unset
++
+ # as_fn_append VAR VALUE
+ # ----------------------
+ # Append the text in VALUE to the end of the definition contained in VAR. Take
+ # advantage of any shell optimizations that allow amortized linear growth over
+ # repeated appends, instead of the typical quadratic growth present in naive
+ # implementations.
+-if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
++if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null
++then :
+   eval 'as_fn_append ()
+   {
+     eval $1+=\$2
+   }'
+-else
+-  as_fn_append ()
++else case e in #(
++  e) as_fn_append ()
+   {
+     eval $1=\$$1\$2
+-  }
++  } ;;
++esac
+ fi # as_fn_append
+ 
+ # as_fn_arith ARG...
+@@ -52969,16 +55672,18 @@ fi # as_fn_append
+ # Perform arithmetic evaluation on the ARGs, and store the result in the
+ # global $as_val. Take advantage of shells that can avoid forks. The arguments
+ # must be portable across $(()) and expr.
+-if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
++if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null
++then :
+   eval 'as_fn_arith ()
+   {
+     as_val=$(( $* ))
+   }'
+-else
+-  as_fn_arith ()
++else case e in #(
++  e) as_fn_arith ()
+   {
+     as_val=`expr "$@" || test $? -eq 1`
+-  }
++  } ;;
++esac
+ fi # as_fn_arith
+ 
+ 
+@@ -53005,7 +55710,7 @@ as_me=`$as_basename -- "$0" ||
+ $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
+ 	 X"$0" : 'X\(//\)$' \| \
+ 	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
+-$as_echo X/"$0" |
++printf "%s\n" X/"$0" |
+     sed '/^.*\/\([^/][^/]*\)\/*$/{
+ 	    s//\1/
+ 	    q
+@@ -53027,6 +55732,10 @@ as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+ as_cr_digits='0123456789'
+ as_cr_alnum=$as_cr_Letters$as_cr_digits
+ 
++
++# Determine whether it's possible to make 'echo' print without a newline.
++# These variables are no longer used directly by Autoconf, but are AC_SUBSTed
++# for compatibility with existing Makefiles.
+ ECHO_C= ECHO_N= ECHO_T=
+ case `echo -n x` in #(((((
+ -n*)
+@@ -53040,6 +55749,12 @@ case `echo -n x` in #(((((
+   ECHO_N='-n';;
+ esac
+ 
++# For backward compatibility with old third-party macros, we provide
++# the shell variables $as_echo and $as_echo_n.  New code should use
++# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively.
++as_echo='printf %s\n'
++as_echo_n='printf %s'
++
+ rm -f conf$$ conf$$.exe conf$$.file
+ if test -d conf$$.dir; then
+   rm -f conf$$.dir/conf$$.file
+@@ -53051,9 +55766,9 @@ if (echo >conf$$.file) 2>/dev/null; then
+   if ln -s conf$$.file conf$$ 2>/dev/null; then
+     as_ln_s='ln -s'
+     # ... but there are two gotchas:
+-    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+-    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+-    # In both cases, we have to default to `cp -pR'.
++    # 1) On MSYS, both 'ln -s file dir' and 'ln file dir' fail.
++    # 2) DJGPP < 2.04 has no symlinks; 'ln -s' creates a wrapper executable.
++    # In both cases, we have to default to 'cp -pR'.
+     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+       as_ln_s='cp -pR'
+   elif ln conf$$.file conf$$ 2>/dev/null; then
+@@ -53081,7 +55796,7 @@ as_fn_mkdir_p ()
+     as_dirs=
+     while :; do
+       case $as_dir in #(
+-      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
++      *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+       *) as_qdir=$as_dir;;
+       esac
+       as_dirs="'$as_qdir' $as_dirs"
+@@ -53090,7 +55805,7 @@ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ 	 X"$as_dir" : 'X\(//\)[^/]' \| \
+ 	 X"$as_dir" : 'X\(//\)$' \| \
+ 	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
+-$as_echo X"$as_dir" |
++printf "%s\n" X"$as_dir" |
+     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ 	    s//\1/
+ 	    q
+@@ -53134,10 +55849,12 @@ as_test_x='test -x'
+ as_executable_p=as_fn_executable_p
+ 
+ # Sed expression to map a string onto a valid CPP name.
+-as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
++as_sed_cpp="y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
++as_tr_cpp="eval sed '$as_sed_cpp'" # deprecated
+ 
+ # Sed expression to map a string onto a valid variable name.
+-as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
++as_sed_sh="y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
++as_tr_sh="eval sed '$as_sed_sh'" # deprecated
+ 
+ 
+ exec 6>&1
+@@ -53153,7 +55870,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+ # values after options handling.
+ ac_log="
+ This file was extended by OpenJDK $as_me jdk8, which was
+-generated by GNU Autoconf 2.69.  Invocation command line was
++generated by GNU Autoconf 2.72.  Invocation command line was
+ 
+   CONFIG_FILES    = $CONFIG_FILES
+   CONFIG_HEADERS  = $CONFIG_HEADERS
+@@ -53184,7 +55901,7 @@ _ACEOF
+ 
+ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+ ac_cs_usage="\
+-\`$as_me' instantiates files and other configuration actions
++'$as_me' instantiates files and other configuration actions
+ from templates according to the current configuration.  Unless the files
+ and actions are specified as TAGs, all are instantiated by default.
+ 
+@@ -53212,14 +55929,16 @@ Report bugs to <build-dev@openjdk.java.net>.
+ OpenJDK home page: <http://openjdk.java.net>."
+ 
+ _ACEOF
++ac_cs_config=`printf "%s\n" "$ac_configure_args" | sed "$ac_safe_unquote"`
++ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"`
+ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+-ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
++ac_cs_config='$ac_cs_config_escaped'
+ ac_cs_version="\\
+ OpenJDK config.status jdk8
+-configured by $0, generated by GNU Autoconf 2.69,
++configured by $0, generated by GNU Autoconf 2.72,
+   with options \\"\$ac_cs_config\\"
+ 
+-Copyright (C) 2012 Free Software Foundation, Inc.
++Copyright (C) 2023 Free Software Foundation, Inc.
+ This config.status script is free software; the Free Software Foundation
+ gives unlimited permission to copy, distribute and modify it."
+ 
+@@ -53257,15 +55976,15 @@ do
+   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+     ac_cs_recheck=: ;;
+   --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
+-    $as_echo "$ac_cs_version"; exit ;;
++    printf "%s\n" "$ac_cs_version"; exit ;;
+   --config | --confi | --conf | --con | --co | --c )
+-    $as_echo "$ac_cs_config"; exit ;;
++    printf "%s\n" "$ac_cs_config"; exit ;;
+   --debug | --debu | --deb | --de | --d | -d )
+     debug=: ;;
+   --file | --fil | --fi | --f )
+     $ac_shift
+     case $ac_optarg in
+-    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
++    *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+     '') as_fn_error $? "missing file argument" ;;
+     esac
+     as_fn_append CONFIG_FILES " '$ac_optarg'"
+@@ -53273,23 +55992,23 @@ do
+   --header | --heade | --head | --hea )
+     $ac_shift
+     case $ac_optarg in
+-    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
++    *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+     esac
+     as_fn_append CONFIG_HEADERS " '$ac_optarg'"
+     ac_need_defaults=false;;
+   --he | --h)
+     # Conflict between --help and --header
+-    as_fn_error $? "ambiguous option: \`$1'
+-Try \`$0 --help' for more information.";;
++    as_fn_error $? "ambiguous option: '$1'
++Try '$0 --help' for more information.";;
+   --help | --hel | -h )
+-    $as_echo "$ac_cs_usage"; exit ;;
++    printf "%s\n" "$ac_cs_usage"; exit ;;
+   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+   | -silent | --silent | --silen | --sile | --sil | --si | --s)
+     ac_cs_silent=: ;;
+ 
+   # This is an error.
+-  -*) as_fn_error $? "unrecognized option: \`$1'
+-Try \`$0 --help' for more information." ;;
++  -*) as_fn_error $? "unrecognized option: '$1'
++Try '$0 --help' for more information." ;;
+ 
+   *) as_fn_append ac_config_targets " $1"
+      ac_need_defaults=false ;;
+@@ -53310,7 +56029,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ if \$ac_cs_recheck; then
+   set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+   shift
+-  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
++  \printf "%s\n" "running CONFIG_SHELL=$SHELL \$*" >&6
+   CONFIG_SHELL='$SHELL'
+   export CONFIG_SHELL
+   exec "\$@"
+@@ -53324,7 +56043,7 @@ exec 5>>config.log
+   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+ ## Running $as_me. ##
+ _ASBOX
+-  $as_echo "$ac_log"
++  printf "%s\n" "$ac_log"
+ } >&5
+ 
+ _ACEOF
+@@ -53345,7 +56064,7 @@ do
+     "$OUTPUT_ROOT/spec.sh") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/spec.sh:$AUTOCONF_DIR/spec.sh.in" ;;
+     "$OUTPUT_ROOT/Makefile") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in" ;;
+ 
+-  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
++  *) as_fn_error $? "invalid argument: '$ac_config_target'" "$LINENO" 5;;
+   esac
+ done
+ 
+@@ -53355,8 +56074,8 @@ done
+ # We use the long form for the default assignment because of an extremely
+ # bizarre bug on SunOS 4.1.3.
+ if $ac_need_defaults; then
+-  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+-  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
++  test ${CONFIG_FILES+y} || CONFIG_FILES=$config_files
++  test ${CONFIG_HEADERS+y} || CONFIG_HEADERS=$config_headers
+ fi
+ 
+ # Have a temporary directory for convenience.  Make it in the build tree
+@@ -53364,7 +56083,7 @@ fi
+ # creating and moving files from /tmp can sometimes cause problems.
+ # Hook for its removal unless debugging.
+ # Note that there is a small window in which the directory will not be cleaned:
+-# after its creation but before its name has been assigned to `$tmp'.
++# after its creation but before its name has been assigned to '$tmp'.
+ $debug ||
+ {
+   tmp= ac_tmp=
+@@ -53388,7 +56107,7 @@ ac_tmp=$tmp
+ 
+ # Set up the scripts for CONFIG_FILES section.
+ # No need to generate them if there are no CONFIG_FILES.
+-# This happens for instance with `./config.status config.h'.
++# This happens for instance with './config.status config.h'.
+ if test -n "$CONFIG_FILES"; then
+ 
+ 
+@@ -53546,13 +56265,13 @@ fi # test -n "$CONFIG_FILES"
+ 
+ # Set up the scripts for CONFIG_HEADERS section.
+ # No need to generate them if there are no CONFIG_HEADERS.
+-# This happens for instance with `./config.status Makefile'.
++# This happens for instance with './config.status Makefile'.
+ if test -n "$CONFIG_HEADERS"; then
+ cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
+ BEGIN {
+ _ACEOF
+ 
+-# Transform confdefs.h into an awk script `defines.awk', embedded as
++# Transform confdefs.h into an awk script 'defines.awk', embedded as
+ # here-document in config.status, that substitutes the proper values into
+ # config.h.in to produce config.h.
+ 
+@@ -53662,7 +56381,7 @@ do
+   esac
+   case $ac_mode$ac_tag in
+   :[FHL]*:*);;
+-  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
++  :L* | :C*:*) as_fn_error $? "invalid tag '$ac_tag'" "$LINENO" 5;;
+   :[FH]-) ac_tag=-:-;;
+   :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
+   esac
+@@ -53684,33 +56403,33 @@ do
+       -) ac_f="$ac_tmp/stdin";;
+       *) # Look for the file first in the build tree, then in the source tree
+ 	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
+-	 # because $ac_f cannot contain `:'.
++	 # because $ac_f cannot contain ':'.
+ 	 test -f "$ac_f" ||
+ 	   case $ac_f in
+ 	   [\\/$]*) false;;
+ 	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
+ 	   esac ||
+-	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
++	   as_fn_error 1 "cannot find input file: '$ac_f'" "$LINENO" 5;;
+       esac
+-      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
++      case $ac_f in *\'*) ac_f=`printf "%s\n" "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
+       as_fn_append ac_file_inputs " '$ac_f'"
+     done
+ 
+-    # Let's still pretend it is `configure' which instantiates (i.e., don't
++    # Let's still pretend it is 'configure' which instantiates (i.e., don't
+     # use $as_me), people would be surprised to read:
+     #    /* config.h.  Generated by config.status.  */
+     configure_input='Generated from '`
+-	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
++	  printf "%s\n" "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
+ 	`' by configure.'
+     if test x"$ac_file" != x-; then
+       configure_input="$ac_file.  $configure_input"
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
+-$as_echo "$as_me: creating $ac_file" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
++printf "%s\n" "$as_me: creating $ac_file" >&6;}
+     fi
+     # Neutralize special characters interpreted by sed in replacement strings.
+     case $configure_input in #(
+     *\&* | *\|* | *\\* )
+-       ac_sed_conf_input=`$as_echo "$configure_input" |
++       ac_sed_conf_input=`printf "%s\n" "$configure_input" |
+        sed 's/[\\\\&|]/\\\\&/g'`;; #(
+     *) ac_sed_conf_input=$configure_input;;
+     esac
+@@ -53727,7 +56446,7 @@ $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
+ 	 X"$ac_file" : 'X\(//\)[^/]' \| \
+ 	 X"$ac_file" : 'X\(//\)$' \| \
+ 	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
+-$as_echo X"$ac_file" |
++printf "%s\n" X"$ac_file" |
+     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
+ 	    s//\1/
+ 	    q
+@@ -53751,9 +56470,9 @@ $as_echo X"$ac_file" |
+ case "$ac_dir" in
+ .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+ *)
+-  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
++  ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'`
+   # A ".." for each directory in $ac_dir_suffix.
+-  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
++  ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
+   case $ac_top_builddir_sub in
+   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+@@ -53806,8 +56525,8 @@ ac_sed_dataroot='
+ case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
+ *datarootdir*) ac_datarootdir_seen=yes;;
+ *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+-$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
++printf "%s\n" "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+ _ACEOF
+ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+   ac_datarootdir_hack='
+@@ -53820,7 +56539,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ esac
+ _ACEOF
+ 
+-# Neutralize VPATH when `$srcdir' = `.'.
++# Neutralize VPATH when '$srcdir' = '.'.
+ # Shell code in configure.ac might set extrasub.
+ # FIXME: do we really want to maintain this feature?
+ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+@@ -53849,9 +56568,9 @@ test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
+   { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
+   { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
+       "$ac_tmp/out"`; test -z "$ac_out"; } &&
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable 'datarootdir'
+ which seems to be undefined.  Please make sure it is defined" >&5
+-$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
++printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable 'datarootdir'
+ which seems to be undefined.  Please make sure it is defined" >&2;}
+ 
+   rm -f "$ac_tmp/stdin"
+@@ -53867,20 +56586,20 @@ which seems to be undefined.  Please make sure it is defined" >&2;}
+   #
+   if test x"$ac_file" != x-; then
+     {
+-      $as_echo "/* $configure_input  */" \
++      printf "%s\n" "/* $configure_input  */" >&1 \
+       && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
+     } >"$ac_tmp/config.h" \
+       || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+     if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
+-      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
+-$as_echo "$as_me: $ac_file is unchanged" >&6;}
++      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
++printf "%s\n" "$as_me: $ac_file is unchanged" >&6;}
+     else
+       rm -f "$ac_file"
+       mv "$ac_tmp/config.h" "$ac_file" \
+ 	|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
+     fi
+   else
+-    $as_echo "/* $configure_input  */" \
++    printf "%s\n" "/* $configure_input  */" >&1 \
+       && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
+       || as_fn_error $? "could not create -" "$LINENO" 5
+   fi
+@@ -53921,8 +56640,8 @@ if test "$no_create" != yes; then
+   $ac_cs_success || as_fn_exit 1
+ fi
+ if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
+-  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
+-$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
++  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
++printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
+ fi
+ 
+ 
+@@ -54043,3 +56762,4 @@ fi
+     fi
+   fi
+ 
++
+diff --git a/common/autoconf/jdk-options.m4 b/common/autoconf/jdk-options.m4
+index 18ba585209..e46cb823ef 100644
+--- a/common/autoconf/jdk-options.m4
++++ b/common/autoconf/jdk-options.m4
+@@ -152,6 +152,9 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_JVM_VARIANTS],
+   AC_SUBST(JVM_VARIANT_CORE)
+ 
+   INCLUDE_SA=true
++  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
++    INCLUDE_SA=false
++  fi
+   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
+     INCLUDE_SA=false
+   fi
+@@ -539,6 +542,18 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_JDK_VERSION_NUMBERS],
+   AC_SUBST(MACOSX_BUNDLE_NAME_BASE)
+   AC_SUBST(MACOSX_BUNDLE_ID_BASE)
+ 
++  # The company name, if any
++  AC_ARG_WITH(company-name, [AS_HELP_STRING([--with-company-name],
++      [Set company name.])])
++  if test "x$with_company_name" = xyes; then
++    AC_MSG_ERROR([--with-company-name must have a value])
++  elif [ ! [[ $with_company_name =~ ^[[:print:]]*$ ]] ]; then
++    AC_MSG_ERROR([--with-company-name contains non-printing characters: $with_company_name])
++  elif test "x$with_company_name" != x; then
++    COMPANY_NAME="$with_company_name"
++  fi
++  AC_SUBST(COMPANY_NAME)
++
+   # The vendor name, if any
+   AC_ARG_WITH(vendor-name, [AS_HELP_STRING([--with-vendor-name],
+       [Set vendor name. Among others, used to set the 'java.vendor'
+diff --git a/common/autoconf/platform.m4 b/common/autoconf/platform.m4
+index 99c7820224..f83d920e69 100644
+--- a/common/autoconf/platform.m4
++++ b/common/autoconf/platform.m4
+@@ -161,6 +161,24 @@ AC_DEFUN([PLATFORM_EXTRACT_VARS_FROM_OS],
+   esac
+ ])
+ 
++# Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
++# Converts autoconf style OS name to OpenJDK style, into
++# VAR_LIBC.
++AC_DEFUN([PLATFORM_EXTRACT_VARS_FROM_LIBC],
++[
++  case "$1" in
++    *linux*-musl)
++      VAR_LIBC=musl
++      ;;
++    *linux*-gnu)
++      VAR_LIBC=gnu
++      ;;
++    *)
++      VAR_LIBC=default
++      ;;
++  esac
++])
++
+ # Expects $host_os $host_cpu $build_os and $build_cpu
+ # and $with_target_bits to have been setup!
+ #
+@@ -178,9 +196,10 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
+   AC_SUBST(OPENJDK_TARGET_AUTOCONF_NAME)
+   AC_SUBST(OPENJDK_BUILD_AUTOCONF_NAME)
+ 
+-  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
++  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
+   PLATFORM_EXTRACT_VARS_FROM_OS($build_os)
+   PLATFORM_EXTRACT_VARS_FROM_CPU($build_cpu)
++  PLATFORM_EXTRACT_VARS_FROM_LIBC($build_os)
+   # ..and setup our own variables. (Do this explicitely to facilitate searching)
+   OPENJDK_BUILD_OS="$VAR_OS"
+   OPENJDK_BUILD_OS_API="$VAR_OS_API"
+@@ -189,6 +208,7 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
+   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
+   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
+   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
++  OPENJDK_BUILD_LIBC="$VAR_LIBC"
+   AC_SUBST(OPENJDK_BUILD_OS)
+   AC_SUBST(OPENJDK_BUILD_OS_API)
+   AC_SUBST(OPENJDK_BUILD_OS_ENV)
+@@ -196,13 +216,20 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
+   AC_SUBST(OPENJDK_BUILD_CPU_ARCH)
+   AC_SUBST(OPENJDK_BUILD_CPU_BITS)
+   AC_SUBST(OPENJDK_BUILD_CPU_ENDIAN)
++  AC_SUBST(OPENJDK_BUILD_LIBC)
+ 
+   AC_MSG_CHECKING([openjdk-build os-cpu])
+   AC_MSG_RESULT([$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU])
+ 
+-  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
++  if test "x$OPENJDK_BUILD_OS" = "xlinux"; then
++    AC_MSG_CHECKING([openjdk-build C library])
++    AC_MSG_RESULT([$OPENJDK_BUILD_LIBC])
++  fi
++
++  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
+   PLATFORM_EXTRACT_VARS_FROM_OS($host_os)
+   PLATFORM_EXTRACT_VARS_FROM_CPU($host_cpu)
++  PLATFORM_EXTRACT_VARS_FROM_LIBC($host_os)
+   # ... and setup our own variables. (Do this explicitely to facilitate searching)
+   OPENJDK_TARGET_OS="$VAR_OS"
+   OPENJDK_TARGET_OS_API="$VAR_OS_API"
+@@ -211,6 +238,7 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
+   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
+   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
+   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
++  OPENJDK_TARGET_LIBC="$VAR_LIBC"
+   AC_SUBST(OPENJDK_TARGET_OS)
+   AC_SUBST(OPENJDK_TARGET_OS_API)
+   AC_SUBST(OPENJDK_TARGET_OS_ENV)
+@@ -218,9 +246,15 @@ AC_DEFUN([PLATFORM_EXTRACT_TARGET_AND_BUILD],
+   AC_SUBST(OPENJDK_TARGET_CPU_ARCH)
+   AC_SUBST(OPENJDK_TARGET_CPU_BITS)
+   AC_SUBST(OPENJDK_TARGET_CPU_ENDIAN)
++  AC_SUBST(OPENJDK_TARGET_LIBC)
+ 
+   AC_MSG_CHECKING([openjdk-target os-cpu])
+   AC_MSG_RESULT([$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU])
++
++  if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
++    AC_MSG_CHECKING([openjdk-target C library])
++    AC_MSG_RESULT([$OPENJDK_TARGET_LIBC])
++  fi
+ ])
+ 
+ # Check if a reduced build (32-bit on 64-bit platforms) is requested, and modify behaviour
+diff --git a/common/autoconf/spec.gmk.in b/common/autoconf/spec.gmk.in
+index ea4ec8e125..a1eacaeb5a 100644
+--- a/common/autoconf/spec.gmk.in
++++ b/common/autoconf/spec.gmk.in
+@@ -85,6 +85,8 @@ OPENJDK_TARGET_CPU_ARCH:=@OPENJDK_TARGET_CPU_ARCH@
+ OPENJDK_TARGET_CPU_BITS:=@OPENJDK_TARGET_CPU_BITS@
+ OPENJDK_TARGET_CPU_ENDIAN:=@OPENJDK_TARGET_CPU_ENDIAN@
+ 
++OPENJDK_TARGET_LIBC:=@OPENJDK_TARGET_LIBC@
++
+ COMPILE_TYPE:=@COMPILE_TYPE@
+ 
+ # Legacy support
+@@ -108,6 +110,8 @@ OPENJDK_BUILD_CPU_ARCH:=@OPENJDK_BUILD_CPU_ARCH@
+ OPENJDK_BUILD_CPU_BITS:=@OPENJDK_BUILD_CPU_BITS@
+ OPENJDK_BUILD_CPU_ENDIAN:=@OPENJDK_BUILD_CPU_ENDIAN@
+ 
++OPENJDK_BUILD_LIBC:=@OPENJDK_BUILD_LIBC@
++
+ # Legacy OS values for use in release file.
+ REQUIRED_OS_NAME:=@REQUIRED_OS_NAME@
+ REQUIRED_OS_VERSION:=@REQUIRED_OS_VERSION@
+diff --git a/hotspot/make/linux/makefiles/defs.make b/hotspot/make/linux/makefiles/defs.make
+index ec414639d2..5d05825300 100644
+--- a/hotspot/make/linux/makefiles/defs.make
++++ b/hotspot/make/linux/makefiles/defs.make
+@@ -305,6 +305,9 @@ endif
+ 
+ # Serviceability Binaries
+ # No SA Support for PPC, IA64, ARM or zero
++# or if thread_db.h missing (musl)
++
++ifneq ($(wildcard /usr/include/thread_db.h),)
+ ADD_SA_BINARIES/x86   = $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.$(LIBRARY_SUFFIX) \
+                         $(EXPORT_LIB_DIR)/sa-jdi.jar
+ ADD_SA_BINARIES/sparc = $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.$(LIBRARY_SUFFIX) \
+@@ -324,6 +327,11 @@ ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
+     endif
+   endif
+ endif
++else
++ADD_SA_BINARIES/x86     =
++ADD_SA_BINARIES/sparc   =
++ADD_SA_BINARIES/aarch64 =
++endif
+ ADD_SA_BINARIES/ppc   =
+ ADD_SA_BINARIES/ia64  =
+ ADD_SA_BINARIES/arm   =
+diff --git a/hotspot/make/linux/makefiles/sa.make b/hotspot/make/linux/makefiles/sa.make
+index cdcb16a1a3..8d2f31e7cb 100644
+--- a/hotspot/make/linux/makefiles/sa.make
++++ b/hotspot/make/linux/makefiles/sa.make
+@@ -59,9 +59,11 @@ SA_PROPERTIES = $(SA_CLASSDIR)/sa.properties
+ 
+ # if $(AGENT_DIR) does not exist, we don't build SA
+ # also, we don't build SA on Itanium or zero.
++# check for thread_db.h too (musl does not have it).
+ 
+ all: 
+-	if [ -d $(AGENT_DIR) -a "$(SRCARCH)" != "ia64" \
++	if [ -d $(AGENT_DIR) -a -f /usr/include/thread_db.h \
++             -a "$(SRCARCH)" != "ia64" \
+              -a "$(SRCARCH)" != "zero" ] ; then \
+ 	   $(MAKE) -f sa.make $(GENERATED)/sa-jdi.jar; \
+ 	fi
+diff --git a/hotspot/make/linux/makefiles/saproc.make b/hotspot/make/linux/makefiles/saproc.make
+index ffc0ec5ce5..732c7614d6 100644
+--- a/hotspot/make/linux/makefiles/saproc.make
++++ b/hotspot/make/linux/makefiles/saproc.make
+@@ -66,12 +66,15 @@ endif
+ 
+ # if $(AGENT_DIR) does not exist, we don't build SA
+ # also, we don't build SA on Itanium or zero.
++# check for thread_db.h too (musl does not have it).
+ 
++ifneq ($(wildcard /usr/include/thread_db.h),)
+ ifneq ($(wildcard $(AGENT_DIR)),)
+ ifneq ($(filter-out ia64 zero,$(SRCARCH)),)
+   BUILDLIBSAPROC = $(LIBSAPROC)
+ endif
+ endif
++endif
+ 
+ ifneq ($(ALT_SASRCDIR),)
+ ALT_SAINCDIR=-I$(ALT_SASRCDIR) -DALT_SASRCDIR
+diff --git a/hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp b/hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp
+index f661847b66..d40548f680 100644
+--- a/hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp
++++ b/hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp
+@@ -1243,7 +1243,11 @@ bool MacroAssembler::is_load_from_polling_page(int instruction, void* ucontext,
+   // the safepoing polling page.
+   ucontext_t* uc = (ucontext_t*) ucontext;
+   // Set polling address.
++#ifndef MUSL_LIBC
+   address addr = (address)uc->uc_mcontext.regs->gpr[ra] + (ssize_t)ds;
++#else
++  address addr = (address)uc->uc_mcontext.gp_regs[ra] + (ssize_t)ds;
++#endif
+   if (polling_address_ptr != NULL) {
+     *polling_address_ptr = addr;
+   }
+@@ -1264,15 +1268,24 @@ bool MacroAssembler::is_memory_serialization(int instruction, JavaThread* thread
+     int rb = inv_rb_field(instruction);
+ 
+     // look up content of ra and rb in ucontext
++#ifndef MUSL_LIBC
+     address ra_val=(address)uc->uc_mcontext.regs->gpr[ra];
+     long rb_val=(long)uc->uc_mcontext.regs->gpr[rb];
++#else
++    address ra_val=(address)uc->uc_mcontext.gp_regs[ra];
++    long rb_val=(long)uc->uc_mcontext.gp_regs[rb];
++#endif
+     return os::is_memory_serialize_page(thread, ra_val+rb_val);
+   } else if (is_stw(instruction) || is_stwu(instruction)) {
+     int ra = inv_ra_field(instruction);
+     int d1 = inv_d1_field(instruction);
+ 
+     // look up content of ra in ucontext
++#ifndef MUSL_LIBC
+     address ra_val=(address)uc->uc_mcontext.regs->gpr[ra];
++#else
++    address ra_val=(address)uc->uc_mcontext.gp_regs[ra];
++#endif
+     return os::is_memory_serialize_page(thread, ra_val+d1);
+   } else {
+     return false;
+@@ -1335,11 +1348,20 @@ address MacroAssembler::get_stack_bang_address(int instruction, void *ucontext)
+       || (is_stdu(instruction) && rs == 1)) {
+     int ds = inv_ds_field(instruction);
+     // return banged address
++#ifndef MUSL_LIBC
+     return ds+(address)uc->uc_mcontext.regs->gpr[ra];
++#else
++    return ds+(address)uc->uc_mcontext.gp_regs[ra];
++#endif
+   } else if (is_stdux(instruction) && rs == 1) {
+     int rb = inv_rb_field(instruction);
++#ifndef MUSL_LIBC
+     address sp = (address)uc->uc_mcontext.regs->gpr[1];
+     long rb_val = (long)uc->uc_mcontext.regs->gpr[rb];
++#else
++    address sp = (address)uc->uc_mcontext.gp_regs[1];
++    long rb_val = (long)uc->uc_mcontext.gp_regs[rb];
++#endif
+     return ra != 1 || rb_val >= 0 ? NULL         // not a stack bang
+                                   : sp + rb_val; // banged address
+   }
+diff --git a/hotspot/src/os/linux/vm/jvm_linux.cpp b/hotspot/src/os/linux/vm/jvm_linux.cpp
+index ba84788a1b..c22281f7ca 100644
+--- a/hotspot/src/os/linux/vm/jvm_linux.cpp
++++ b/hotspot/src/os/linux/vm/jvm_linux.cpp
+@@ -154,7 +154,9 @@ struct siglabel siglabels[] = {
+ #ifdef SIGSTKFLT
+   "STKFLT",     SIGSTKFLT,      /* Stack fault.  */
+ #endif
++#ifdef SIGCLD
+   "CLD",        SIGCLD,         /* Same as SIGCHLD (System V).  */
++#endif
+   "CHLD",       SIGCHLD,        /* Child status has changed (POSIX).  */
+   "CONT",       SIGCONT,        /* Continue (POSIX).  */
+   "STOP",       SIGSTOP,        /* Stop, unblockable (POSIX).  */
+diff --git a/hotspot/src/os/linux/vm/os_linux.cpp b/hotspot/src/os/linux/vm/os_linux.cpp
+index 742e17d115..d9a9877970 100644
+--- a/hotspot/src/os/linux/vm/os_linux.cpp
++++ b/hotspot/src/os/linux/vm/os_linux.cpp
+@@ -96,7 +96,6 @@
+ # include <string.h>
+ # include <syscall.h>
+ # include <sys/sysinfo.h>
+-# include <gnu/libc-version.h>
+ # include <sys/ipc.h>
+ # include <sys/shm.h>
+ # include <link.h>
+@@ -104,6 +103,10 @@
+ # include <inttypes.h>
+ # include <sys/ioctl.h>
+ 
++#ifndef MUSL_LIBC
++#include <gnu/libc-version.h>
++#endif
++
+ PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
+ 
+ #ifndef _GNU_SOURCE
+@@ -145,7 +148,7 @@ const int os::Linux::_vm_default_page_size = (8 * K);
+ bool os::Linux::_is_floating_stack = false;
+ bool os::Linux::_is_NPTL = false;
+ bool os::Linux::_supports_fast_thread_cpu_time = false;
+-const char * os::Linux::_glibc_version = NULL;
++const char * os::Linux::_libc_version = NULL;
+ const char * os::Linux::_libpthread_version = NULL;
+ pthread_condattr_t os::Linux::_condattr[1];
+ 
+@@ -585,6 +588,15 @@ void os::Linux::hotspot_sigmask(Thread* thread) {
+ // detecting pthread library
+ 
+ void os::Linux::libpthread_init() {
++#ifdef MUSL_LIBC
++  // Hard code Alpine Linux supported musl compatible settings.
++  // confstr() from musl libc returns EINVAL for
++  // _CS_GNU_LIBC_VERSION and _CS_GNU_LIBPTHREAD_VERSION
++  os::Linux::set_libc_version("musl - unknown");
++  os::Linux::set_libpthread_version("musl - unknown");
++  os::Linux::set_is_NPTL();
++  os::Linux::set_is_floating_stack();
++#else
+   // Save glibc and pthread version strings. Note that _CS_GNU_LIBC_VERSION
+   // and _CS_GNU_LIBPTHREAD_VERSION are supported in glibc >= 2.3.2. Use a
+   // generic name for earlier versions.
+@@ -600,13 +612,13 @@ void os::Linux::libpthread_init() {
+   if (n > 0) {
+      char *str = (char *)malloc(n, mtInternal);
+      confstr(_CS_GNU_LIBC_VERSION, str, n);
+-     os::Linux::set_glibc_version(str);
++     os::Linux::set_libc_version(str);
+   } else {
+      // _CS_GNU_LIBC_VERSION is not supported, try gnu_get_libc_version()
+      static char _gnu_libc_version[32];
+      jio_snprintf(_gnu_libc_version, sizeof(_gnu_libc_version),
+               "glibc %s %s", gnu_get_libc_version(), gnu_get_libc_release());
+-     os::Linux::set_glibc_version(_gnu_libc_version);
++     os::Linux::set_libc_version(_gnu_libc_version);
+   }
+ 
+   n = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, 0);
+@@ -619,7 +631,7 @@ void os::Linux::libpthread_init() {
+      // So sysconf(_SC_THREAD_THREADS_MAX) will return a positive value.
+      // On the other hand, NPTL does not have such a limit, sysconf()
+      // will return -1 and errno is not changed. Check if it is really NPTL.
+-     if (strcmp(os::Linux::glibc_version(), "glibc 2.3.2") == 0 &&
++     if (strcmp(os::Linux::libc_version(), "glibc 2.3.2") == 0 &&
+          strstr(str, "NPTL") &&
+          sysconf(_SC_THREAD_THREADS_MAX) > 0) {
+        free(str);
+@@ -643,6 +655,7 @@ void os::Linux::libpthread_init() {
+   if (os::Linux::is_NPTL() || os::Linux::supports_variable_stack_size()) {
+      os::Linux::set_is_floating_stack();
+   }
++#endif
+ }
+ 
+ /////////////////////////////////////////////////////////////////////////////
+@@ -800,7 +813,7 @@ static void *java_start(Thread *thread) {
+   // processors with hyperthreading technology.
+   static int counter = 0;
+   int pid = os::current_process_id();
+-  alloca(((pid ^ counter++) & 7) * 128);
++  void *tmp = alloca(((pid ^ counter++) & 7) * 128);
+ 
+   ThreadLocalStorage::set_thread(thread);
+ 
+@@ -2295,7 +2308,7 @@ void os::Linux::print_distro_info(outputStream* st) {
+ void os::Linux::print_libversion_info(outputStream* st) {
+   // libc, pthread
+   st->print("libc:");
+-  st->print("%s ", os::Linux::glibc_version());
++  st->print("%s ", os::Linux::libc_version());
+   st->print("%s ", os::Linux::libpthread_version());
+   if (os::Linux::is_LinuxThreads()) {
+      st->print("(%s stack)", os::Linux::is_floating_stack() ? "floating" : "fixed");
+@@ -3012,6 +3025,14 @@ extern "C" JNIEXPORT void numa_warn(int number, char *where, ...) { }
+ extern "C" JNIEXPORT void numa_error(char *where) { }
+ extern "C" JNIEXPORT int fork1() { return fork(); }
+ 
++#ifdef MUSL_LIBC
++  // dlvsym is not a part of POSIX and musl libc doesn't implement it.
++  static void *dlvsym(void *handle, const char *name, const char *ver)
++  {
++    return dlsym(handle, name);
++  }
++#endif
++
+ // Handle request to load libnuma symbol version 1.1 (API v1). If it fails
+ // load symbol from base version instead.
+ void* os::Linux::libnuma_dlsym(void* handle, const char *name) {
+@@ -5037,7 +5058,8 @@ void os::Linux::check_signal_handler(int sig) {
+   }
+ 
+   if (thisHandler != jvmHandler) {
+-    tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
++    if(exception_name(sig, buf, O_BUFLEN))
++      tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
+     tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN));
+     tty->print_cr("  found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN));
+     // No need to check this sig any longer
+@@ -5227,7 +5249,7 @@ jint os::init_2(void)
+   Linux::libpthread_init();
+   if (PrintMiscellaneous && (Verbose || WizardMode)) {
+      tty->print_cr("[HotSpot is running with %s, %s(%s)]\n",
+-          Linux::glibc_version(), Linux::libpthread_version(),
++          Linux::libc_version(), Linux::libpthread_version(),
+           Linux::is_floating_stack() ? "floating stack" : "fixed stack");
+   }
+ 
+diff --git a/hotspot/src/os/linux/vm/os_linux.hpp b/hotspot/src/os/linux/vm/os_linux.hpp
+index ed15777877..f47c2cb731 100644
+--- a/hotspot/src/os/linux/vm/os_linux.hpp
++++ b/hotspot/src/os/linux/vm/os_linux.hpp
+@@ -62,7 +62,7 @@ class Linux {
+   static address   _initial_thread_stack_bottom;
+   static uintptr_t _initial_thread_stack_size;
+ 
+-  static const char *_glibc_version;
++  static const char *_libc_version;
+   static const char *_libpthread_version;
+ 
+   static bool _is_floating_stack;
+@@ -89,7 +89,7 @@ class Linux {
+   static int commit_memory_impl(char* addr, size_t bytes,
+                                 size_t alignment_hint, bool exec);
+ 
+-  static void set_glibc_version(const char *s)      { _glibc_version = s; }
++  static void set_libc_version(const char *s)       { _libc_version = s; }
+   static void set_libpthread_version(const char *s) { _libpthread_version = s; }
+ 
+   static bool supports_variable_stack_size();
+@@ -183,7 +183,7 @@ class Linux {
+   static bool chained_handler(int sig, siginfo_t* siginfo, void* context);
+ 
+   // GNU libc and libpthread version strings
+-  static const char *glibc_version()          { return _glibc_version; }
++  static const char *libc_version()           { return _libc_version; }
+   static const char *libpthread_version()     { return _libpthread_version; }
+ 
+   // NPTL or LinuxThreads?
+diff --git a/hotspot/src/os/linux/vm/os_linux.inline.hpp b/hotspot/src/os/linux/vm/os_linux.inline.hpp
+index a23bd56313..80b977711e 100644
+--- a/hotspot/src/os/linux/vm/os_linux.inline.hpp
++++ b/hotspot/src/os/linux/vm/os_linux.inline.hpp
+@@ -33,9 +33,14 @@
+ 
+ #include <unistd.h>
+ #include <sys/socket.h>
+-#include <sys/poll.h>
+ #include <netdb.h>
+ 
++#ifndef MUSL_LIBC
++#include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
++
+ inline void* os::thread_local_storage_at(int index) {
+   return pthread_getspecific((pthread_key_t)index);
+ }
+diff --git a/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp b/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
+index db1cb10499..5623377727 100644
+--- a/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
++++ b/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
+@@ -72,7 +72,12 @@
+ # include <pwd.h>
+ # include <poll.h>
+ # include <ucontext.h>
+-# include <fpu_control.h>
++
++#ifndef MUSL_LIBC
++#include <fpu_control.h>
++#else
++#include <linux/types.h>  /* provides __u64 */
++#endif
+ 
+ #define REG_FP 29
+ 
+diff --git a/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp b/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp
+index ffee3b5089..17c1aec161 100644
+--- a/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp
++++ b/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp
+@@ -75,6 +75,9 @@
+ # include <poll.h>
+ # include <ucontext.h>
+ 
++#ifdef MUSL_LIBC
++#include <asm/ptrace.h>
++#endif
+ 
+ address os::current_stack_pointer() {
+   intptr_t* csp;
+@@ -110,11 +113,19 @@ address os::Linux::ucontext_get_pc(ucontext_t * uc) {
+   //   it because the volatile registers are not needed to make setcontext() work.
+   //   Hopefully it was zero'd out beforehand.
+   guarantee(uc->uc_mcontext.regs != NULL, "only use ucontext_get_pc in sigaction context");
++#ifndef MUSL_LIBC
+   return (address)uc->uc_mcontext.regs->nip;
++#else
++  return (address)uc->uc_mcontext.gp_regs[PT_NIP];
++#endif
+ }
+ 
+ intptr_t* os::Linux::ucontext_get_sp(ucontext_t * uc) {
++#ifndef MUSL_LIBC
+   return (intptr_t*)uc->uc_mcontext.regs->gpr[1/*REG_SP*/];
++#else
++  return (intptr_t*)uc->uc_mcontext.gp_regs[1/*REG_SP*/];
++#endif
+ }
+ 
+ intptr_t* os::Linux::ucontext_get_fp(ucontext_t * uc) {
+@@ -217,7 +228,11 @@ JVM_handle_linux_signal(int sig,
+   if ((sig == SIGSEGV || sig == SIGBUS) && uc) {
+     address const pc = os::Linux::ucontext_get_pc(uc);
+     if (pc && StubRoutines::is_safefetch_fault(pc)) {
++#ifndef MUSL_LIBC
+       uc->uc_mcontext.regs->nip = (unsigned long)StubRoutines::continuation_for_safefetch_fault(pc);
++#else
++      uc->uc_mcontext.gp_regs[PT_NIP] = (unsigned long)StubRoutines::continuation_for_safefetch_fault(pc);
++#endif
+       return true;
+     }
+   }
+@@ -368,7 +383,11 @@ JVM_handle_linux_signal(int sig,
+           // continue at the next instruction after the faulting read. Returning
+           // garbage from this read is ok.
+           thread->set_pending_unsafe_access_error();
++#ifndef MUSL_LIBC
+           uc->uc_mcontext.regs->nip = ((unsigned long)pc) + 4;
++#else
++          uc->uc_mcontext.gp_regs[PT_NIP] = ((unsigned long)pc) + 4;
++#endif
+           return true;
+         }
+       }
+@@ -387,7 +406,11 @@ JVM_handle_linux_signal(int sig,
+         // continue at the next instruction after the faulting read. Returning
+         // garbage from this read is ok.
+         thread->set_pending_unsafe_access_error();
++#ifndef MUSL_LIBC
+         uc->uc_mcontext.regs->nip = ((unsigned long)pc) + 4;
++#else
++        uc->uc_mcontext.gp_regs[PT_NIP] = ((unsigned long)pc) + 4;
++#endif
+         return true;
+       }
+     }
+@@ -410,7 +433,11 @@ JVM_handle_linux_signal(int sig,
+   if (stub != NULL) {
+     // Save all thread context in case we need to restore it.
+     if (thread != NULL) thread->set_saved_exception_pc(pc);
++#ifndef MUSL_LIBC
+     uc->uc_mcontext.regs->nip = (unsigned long)stub;
++#else
++    uc->uc_mcontext.gp_regs[PT_NIP] = (unsigned long)stub;
++#endif
+     return true;
+   }
+ 
+@@ -568,6 +595,7 @@ void os::print_context(outputStream *st, void *context) {
+   ucontext_t* uc = (ucontext_t*)context;
+ 
+   st->print_cr("Registers:");
++#ifndef MUSL_LIBC
+   st->print("pc =" INTPTR_FORMAT "  ", uc->uc_mcontext.regs->nip);
+   st->print("lr =" INTPTR_FORMAT "  ", uc->uc_mcontext.regs->link);
+   st->print("ctr=" INTPTR_FORMAT "  ", uc->uc_mcontext.regs->ctr);
+@@ -576,6 +604,16 @@ void os::print_context(outputStream *st, void *context) {
+     st->print("r%-2d=" INTPTR_FORMAT "  ", i, uc->uc_mcontext.regs->gpr[i]);
+     if (i % 3 == 2) st->cr();
+   }
++#else // Musl
++  st->print("pc =" INTPTR_FORMAT "  ", uc->uc_mcontext.gp_regs[PT_NIP]);
++  st->print("lr =" INTPTR_FORMAT "  ", uc->uc_mcontext.gp_regs[PT_LNK]);
++  st->print("ctr=" INTPTR_FORMAT "  ", uc->uc_mcontext.gp_regs[PT_CTR]);
++  st->cr();
++  for (int i = 0; i < 32; i++) {
++    st->print("r%-2d=" INTPTR_FORMAT "  ", i, uc->uc_mcontext.gp_regs[i]);
++    if (i % 3 == 2) st->cr();
++  }
++#endif
+   st->cr();
+   st->cr();
+ 
+@@ -604,7 +642,11 @@ void os::print_register_info(outputStream *st, void *context) {
+   // this is only for the "general purpose" registers
+   for (int i = 0; i < 32; i++) {
+     st->print("r%-2d=", i);
++#ifndef MUSL_LIBC
+     print_location(st, uc->uc_mcontext.regs->gpr[i]);
++#else
++    print_location(st, uc->uc_mcontext.gp_regs[i]);
++#endif
+   }
+   st->cr();
+ }
+diff --git a/hotspot/src/os_cpu/linux_ppc/vm/thread_linux_ppc.cpp b/hotspot/src/os_cpu/linux_ppc/vm/thread_linux_ppc.cpp
+index 802677f470..dd68a34549 100644
+--- a/hotspot/src/os_cpu/linux_ppc/vm/thread_linux_ppc.cpp
++++ b/hotspot/src/os_cpu/linux_ppc/vm/thread_linux_ppc.cpp
+@@ -27,6 +27,10 @@
+ #include "runtime/frame.inline.hpp"
+ #include "runtime/thread.hpp"
+ 
++#ifdef MUSL_LIBC
++#include <asm/ptrace.h>
++#endif
++
+ bool JavaThread::pd_get_top_frame_for_profiling(frame* fr_addr, void* ucontext, bool isInJava) {
+   assert(this->is_Java_thread(), "must be JavaThread");
+ 
+@@ -42,8 +46,13 @@ bool JavaThread::pd_get_top_frame_for_profiling(frame* fr_addr, void* ucontext,
+   // if we were running Java code when SIGPROF came in.
+   if (isInJava) {
+     ucontext_t* uc = (ucontext_t*) ucontext;
++#ifndef MUSL_LIBC
+     frame ret_frame((intptr_t*)uc->uc_mcontext.regs->gpr[1/*REG_SP*/],
+                      (address)uc->uc_mcontext.regs->nip);
++#else
++    frame ret_frame((intptr_t*)uc->uc_mcontext.gp_regs[1/*REG_SP*/],
++                     (address)uc->uc_mcontext.gp_regs[PT_NIP]);
++#endif
+ 
+     if (ret_frame.pc() == NULL) {
+       // ucontext wasn't useful
+@@ -56,7 +65,11 @@ bool JavaThread::pd_get_top_frame_for_profiling(frame* fr_addr, void* ucontext,
+       if (m == NULL || !m->is_valid_method()) return false;
+       if (!Metaspace::contains((const void*)m)) return false;
+ 
++#ifndef MUSL_LIBC
+       uint64_t reg_bcp = uc->uc_mcontext.regs->gpr[14/*R14_bcp*/];
++#else
++      uint64_t reg_bcp = uc->uc_mcontext.gp_regs[14/*R14_bcp*/];
++#endif
+       uint64_t istate_bcp = istate->bcp;
+       uint64_t code_start = (uint64_t)(m->code_base());
+       uint64_t code_end = (uint64_t)(m->code_base() + m->code_size());
+diff --git a/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp b/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp
+index 12b5ca0acd..b489fc89be 100644
+--- a/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp
++++ b/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp
+@@ -72,7 +72,10 @@
+ # include <pwd.h>
+ # include <poll.h>
+ # include <ucontext.h>
+-# include <fpu_control.h>
++
++#ifndef MUSL_LIBC
++#include <fpu_control.h>
++#endif
+ 
+ #ifdef AMD64
+ #define REG_SP REG_RSP
+@@ -544,6 +547,11 @@ JVM_handle_linux_signal(int sig,
+   return true; // Mute compiler
+ }
+ 
++#ifdef MUSL_LIBC
++#define _FPU_GETCW(cw) __asm__ __volatile__ ("fnstcw %0" : "=m" (*&cw))
++#define _FPU_SETCW(cw) __asm__ __volatile__ ("fldcw %0" : : "m" (*&cw))
++#endif
++
+ void os::Linux::init_thread_fpu_state(void) {
+ #ifndef AMD64
+   // set fpu to 53 bit precision
+diff --git a/hotspot/src/os_cpu/linux_x86/vm/threadLS_linux_x86.hpp b/hotspot/src/os_cpu/linux_x86/vm/threadLS_linux_x86.hpp
+index f3f2f26f88..00b472693a 100644
+--- a/hotspot/src/os_cpu/linux_x86/vm/threadLS_linux_x86.hpp
++++ b/hotspot/src/os_cpu/linux_x86/vm/threadLS_linux_x86.hpp
+@@ -32,7 +32,9 @@
+   // map stack pointer to thread pointer - see notes in threadLS_linux_x86.cpp
+   #define SP_BITLENGTH  32
+   #define PAGE_SHIFT    12
++  #if !defined(MUSL_LIBC) || !defined(PAGE_SIZE)
+   #define PAGE_SIZE     (1UL << PAGE_SHIFT)
++  #endif
+   static Thread* _sp_map[1UL << (SP_BITLENGTH - PAGE_SHIFT)];
+ 
+ public:
+diff --git a/jdk/make/gensrc/GensrcMisc.gmk b/jdk/make/gensrc/GensrcMisc.gmk
+index 0e3dee5ca3..fc19b082cc 100644
+--- a/jdk/make/gensrc/GensrcMisc.gmk
++++ b/jdk/make/gensrc/GensrcMisc.gmk
+@@ -30,6 +30,11 @@ include ProfileNames.gmk
+ # string and the runtime name into the Version.java file.
+ # To be printed by java -version
+ 
++company_name =
++ifneq ($(COMPANY_NAME),N/A)
++  company_name=($(COMPANY_NAME))
++endif
++
+ $(JDK_OUTPUTDIR)/gensrc/sun/misc/Version.java \
+ $(PROFILE_VERSION_JAVA_TARGETS): \
+     $(JDK_TOPDIR)/src/share/classes/sun/misc/Version.java.template
+@@ -41,6 +46,7 @@ $(PROFILE_VERSION_JAVA_TARGETS): \
+ 	    -e 's/@@java_runtime_version@@/$(FULL_VERSION)/g' \
+ 	    -e 's/@@java_runtime_name@@/$(RUNTIME_NAME)/g' \
+ 	    -e 's/@@java_profile_name@@/$(call profile_version_name, $@)/g' \
++      -e 's/@@company_name@@/$(company_name)/g' \
+ 	    $< > $@.tmp
+ 	$(MV) $@.tmp $@
+ 
+diff --git a/jdk/src/aix/native/java/net/aix_close.c b/jdk/src/aix/native/java/net/aix_close.c
+index 5bf798aba1..b6696631a0 100644
+--- a/jdk/src/aix/native/java/net/aix_close.c
++++ b/jdk/src/aix/native/java/net/aix_close.c
+@@ -54,7 +54,11 @@
+ #include <unistd.h>
+ #include <errno.h>
+ 
++#ifndef MUSL_LIBC
+ #include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
+ #include "jvm.h"
+ 
+ /*
+diff --git a/jdk/src/aix/native/sun/nio/ch/AixNativeThread.c b/jdk/src/aix/native/sun/nio/ch/AixNativeThread.c
+index c0d5857962..66098cc36d 100644
+--- a/jdk/src/aix/native/sun/nio/ch/AixNativeThread.c
++++ b/jdk/src/aix/native/sun/nio/ch/AixNativeThread.c
+@@ -32,7 +32,12 @@
+ #include "sun_nio_ch_NativeThread.h"
+ 
+ #include <pthread.h>
++
++#ifndef MUSL_LIBC
+ #include <sys/signal.h>
++#else
++#include <signal.h>
++#endif
+ 
+ /* Also defined in src/aix/native/java/net/aix_close.c */
+ #define INTERRUPT_SIGNAL (SIGRTMAX - 1)
+diff --git a/jdk/src/aix/native/sun/nio/ch/AixPollPort.c b/jdk/src/aix/native/sun/nio/ch/AixPollPort.c
+index 70064b890e..c0466dcc9f 100644
+--- a/jdk/src/aix/native/sun/nio/ch/AixPollPort.c
++++ b/jdk/src/aix/native/sun/nio/ch/AixPollPort.c
+@@ -34,13 +34,18 @@
+ #include <unistd.h>
+ #include <sys/types.h>
+ #include <sys/socket.h>
+-#include <sys/poll.h>
+ #include <sys/pollset.h>
+ #include <fcntl.h>
+ #include <stddef.h>
+ #include <dlfcn.h>
+ #include <errno.h>
+ 
++#ifndef MUSL_LIBC
++#include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
++
+ /* Initially copied from src/solaris/native/sun/nio/ch/nio_util.h */
+ #define RESTARTABLE(_cmd, _result) do { \
+   do { \
+diff --git a/jdk/src/macosx/javavm/export/jvm_md.h b/jdk/src/macosx/javavm/export/jvm_md.h
+index 012bb1babe..592bfb5ab9 100644
+--- a/jdk/src/macosx/javavm/export/jvm_md.h
++++ b/jdk/src/macosx/javavm/export/jvm_md.h
+@@ -60,7 +60,12 @@
+ #include <sys/stat.h>
+ #include <fcntl.h>
+ #include <errno.h>
++
++#ifndef MUSL_LIBC
+ #include <sys/signal.h>
++#else
++#include <signal.h>
++#endif
+ 
+ /* O Flags */
+ 
+diff --git a/jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp b/jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp
+index f58c94956c..0afbf6bb98 100644
+--- a/jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp
++++ b/jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp
+@@ -46,6 +46,10 @@
+ 
+ #include "zip.h"
+ 
++#ifdef MUSL_LIBC
++#define uchar unsigned char
++#endif
++
+ #ifdef NO_ZLIB
+ 
+ inline bool jar::deflate_bytes(bytes& head, bytes& tail) {
+diff --git a/jdk/src/share/native/com/sun/java/util/jar/pack/zip.h b/jdk/src/share/native/com/sun/java/util/jar/pack/zip.h
+index 14ffc9d65b..4137714f7d 100644
+--- a/jdk/src/share/native/com/sun/java/util/jar/pack/zip.h
++++ b/jdk/src/share/native/com/sun/java/util/jar/pack/zip.h
+@@ -23,9 +23,13 @@
+  * questions.
+  */
+ 
++#ifndef MUSL_LIBC
+ #define ushort unsigned short
+ #define uint   unsigned int
+ #define uchar  unsigned char
++#else
++#include <sys/types.h>
++#endif
+ 
+ struct unpacker;
+ 
+diff --git a/jdk/src/share/native/java/lang/System.c b/jdk/src/share/native/java/lang/System.c
+index 04ef657465..b06a38f87e 100644
+--- a/jdk/src/share/native/java/lang/System.c
++++ b/jdk/src/share/native/java/lang/System.c
+@@ -110,13 +110,13 @@ Java_java_lang_System_identityHashCode(JNIEnv *env, jobject this, jobject x)
+ 
+ /* Third party may overwrite these values. */
+ #ifndef VENDOR
+-#define VENDOR "Oracle Corporation"
++#define VENDOR "Eclipse Foundation"
+ #endif
+ #ifndef VENDOR_URL
+-#define VENDOR_URL "http://java.oracle.com/"
++#define VENDOR_URL "https://adoptium.net/"
+ #endif
+ #ifndef VENDOR_URL_BUG
+-#define VENDOR_URL_BUG "http://bugreport.sun.com/bugreport/"
++#define VENDOR_URL_BUG "https://github.com/adoptium/adoptium-support/issues"
+ #endif
+ 
+ #define JAVA_MAX_SUPPORTED_VERSION 52
+diff --git a/jdk/src/share/native/sun/awt/medialib/mlib_types.h b/jdk/src/share/native/sun/awt/medialib/mlib_types.h
+index aba0394ffd..ad548aef64 100644
+--- a/jdk/src/share/native/sun/awt/medialib/mlib_types.h
++++ b/jdk/src/share/native/sun/awt/medialib/mlib_types.h
+@@ -27,6 +27,10 @@
+ #ifndef MLIB_TYPES_H
+ #define MLIB_TYPES_H
+ 
++#ifdef MUSL_LIBC
++#include <stddef.h>                     /* for NULL */
++#endif
++
+ #include <limits.h>
+ #if defined(_MSC_VER)
+ #include <float.h>                      /* for FLT_MAX and DBL_MAX */
+diff --git a/jdk/src/solaris/bin/java_md_solinux.c b/jdk/src/solaris/bin/java_md_solinux.c
+index e5056c44a7..58d3d7492a 100644
+--- a/jdk/src/solaris/bin/java_md_solinux.c
++++ b/jdk/src/solaris/bin/java_md_solinux.c
+@@ -292,6 +292,10 @@ RequiresSetenv(int wanted, const char *jvmpath) {
+     char *dmllp = NULL;
+     char *p; /* a utility pointer */
+ 
++#ifdef MUSL_LIBC
++    return JNI_TRUE;
++#endif
++
+ #ifdef AIX
+     /* We always have to set the LIBPATH on AIX because ld doesn't support $ORIGIN. */
+     return JNI_TRUE;
+diff --git a/jdk/src/solaris/javavm/export/jvm_md.h b/jdk/src/solaris/javavm/export/jvm_md.h
+index 5c681914bb..a181456010 100644
+--- a/jdk/src/solaris/javavm/export/jvm_md.h
++++ b/jdk/src/solaris/javavm/export/jvm_md.h
+@@ -65,7 +65,12 @@
+ #include <sys/stat.h>
+ #include <fcntl.h>
+ #include <errno.h>
++
++#ifndef MUSL_LIBC
+ #include <sys/signal.h>
++#else
++#include <signal.h>
++#endif
+ 
+ /* O Flags */
+ 
+diff --git a/jdk/src/solaris/native/java/lang/UNIXProcess_md.c b/jdk/src/solaris/native/java/lang/UNIXProcess_md.c
+index 9b510ad3a9..ad233a2a76 100644
+--- a/jdk/src/solaris/native/java/lang/UNIXProcess_md.c
++++ b/jdk/src/solaris/native/java/lang/UNIXProcess_md.c
+@@ -550,7 +550,11 @@ static pid_t
+ startChild(JNIEnv *env, jobject process, ChildStuff *c, const char *helperpath) {
+     switch (c->mode) {
+       case MODE_VFORK:
++// use regular fork when running on musl
++// this should fix deadlocks on aarch64
++#ifndef MUSL_LIBC
+         return vforkChild(c);
++#endif
+       case MODE_FORK:
+         return forkChild(c);
+ #if defined(__solaris__) || defined(_ALLBSD_SOURCE) || defined(_AIX)
+@@ -649,8 +653,12 @@ Java_java_lang_UNIXProcess_forkAndExec(JNIEnv *env,
+     if (resultPid < 0) {
+         switch (c->mode) {
+           case MODE_VFORK:
++// use regular fork when running on musl
++// this should fix deadlocks on aarch64
++#ifndef MUSL_LIBC
+             throwIOException(env, errno, "vfork failed");
+             break;
++#endif
+           case MODE_FORK:
+             throwIOException(env, errno, "fork failed");
+             break;
+diff --git a/jdk/src/solaris/native/java/lang/childproc.c b/jdk/src/solaris/native/java/lang/childproc.c
+index c0045d5371..2d20db6185 100644
+--- a/jdk/src/solaris/native/java/lang/childproc.c
++++ b/jdk/src/solaris/native/java/lang/childproc.c
+@@ -23,7 +23,6 @@
+  * questions.
+  */
+ 
+-#include <dirent.h>
+ #include <errno.h>
+ #include <fcntl.h>
+ #include <stdlib.h>
+@@ -31,6 +30,12 @@
+ #include <unistd.h>
+ #include <limits.h>
+ 
++#ifndef MUSL_LIBC
++#include <dirent.h>
++#else
++#include <poll.h>
++#endif
++
+ #include "childproc.h"
+ 
+ const char * const *parentPathv;
+@@ -57,6 +62,8 @@ closeSafely(int fd)
+     return (fd == -1) ? 0 : close(fd);
+ }
+ 
++#ifndef MUSL_LIBC
++
+ int
+ isAsciiDigit(char c)
+ {
+@@ -115,6 +122,54 @@ closeDescriptors(void)
+     return 1;
+ }
+ 
++#else // Musl
++
++int
++closeDescriptors(void)
++{
++    int from_fd = FAIL_FILENO + 1;
++    struct pollfd pfds[1024];
++    int i, total, nclosed = 0;
++    int max_fd = sysconf(_SC_OPEN_MAX);
++
++    if (max_fd < 0)
++        return 0;
++
++    /* init events */
++    total = max_fd - from_fd;
++    for (i = 0; i < (total < 1024 ? total : 1024); i++) {
++        pfds[i].events = 0;
++    }
++
++    while (from_fd < max_fd) {
++        int nfds, r = 0;
++
++        total = max_fd - from_fd;
++        nfds =  total < 1024 ? total : 1024;
++
++        for (i = 0; i < nfds; i++)
++            pfds[i].fd = from_fd + i;
++
++        do {
++            r = poll(pfds, nfds, 0);
++        } while (r == -1 && errno == EINTR);
++
++        if (r < 0)
++            return 0;
++
++
++        for (i = 0; i < nfds; i++)
++            if (pfds[i].revents != POLLNVAL) {
++                nclosed++;
++                close(pfds[i].fd);
++            }
++        from_fd += nfds;
++    }
++    return 1;
++}
++
++#endif
++
+ int
+ moveDescriptor(int fd_from, int fd_to)
+ {
+diff --git a/jdk/src/solaris/native/java/net/Inet4AddressImpl.c b/jdk/src/solaris/native/java/net/Inet4AddressImpl.c
+index 8b2e3cdce9..6a4a513c0d 100644
+--- a/jdk/src/solaris/native/java/net/Inet4AddressImpl.c
++++ b/jdk/src/solaris/native/java/net/Inet4AddressImpl.c
+@@ -47,7 +47,7 @@
+ 
+ #include "java_net_Inet4AddressImpl.h"
+ 
+-#if defined(__GLIBC__) || (defined(__FreeBSD__) && (__FreeBSD_version >= 601104))
++#if defined(__linux__) || (defined(__FreeBSD__) && (__FreeBSD_version >= 601104))
+ #define HAS_GLIBC_GETHOSTBY_R   1
+ #endif
+ 
+diff --git a/jdk/src/solaris/native/java/net/bsd_close.c b/jdk/src/solaris/native/java/net/bsd_close.c
+index a6050e1f9a..e77f973443 100644
+--- a/jdk/src/solaris/native/java/net/bsd_close.c
++++ b/jdk/src/solaris/native/java/net/bsd_close.c
+@@ -38,7 +38,12 @@
+ #include <sys/uio.h>
+ #include <unistd.h>
+ #include <errno.h>
++
++#ifndef MUSL_LIBC
+ #include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
+ #include "jvm.h"
+ 
+ /*
+diff --git a/jdk/src/solaris/native/java/net/linux_close.c b/jdk/src/solaris/native/java/net/linux_close.c
+index c7a148c746..327cc7ac5b 100644
+--- a/jdk/src/solaris/native/java/net/linux_close.c
++++ b/jdk/src/solaris/native/java/net/linux_close.c
+@@ -36,7 +36,12 @@
+ #include <sys/uio.h>
+ #include <unistd.h>
+ #include <errno.h>
++
++#ifndef MUSL_LIBC
+ #include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
+ #include "jvm.h"
+ 
+ /*
+@@ -59,7 +64,7 @@ typedef struct {
+ /*
+  * Signal to unblock thread
+  */
+-static int sigWakeup = (__SIGRTMAX - 2);
++static int sigWakeup;
+ 
+ /*
+  * fdTable holds one entry per file descriptor, up to a certain
+@@ -148,6 +153,9 @@ static void __attribute((constructor)) init() {
+     /*
+      * Setup the signal handler
+      */
++#ifndef _AIX
++    sigWakeup = SIGRTMAX - 2;
++#endif
+     sa.sa_handler = sig_wakeup;
+     sa.sa_flags   = 0;
+     sigemptyset(&sa.sa_mask);
+diff --git a/jdk/src/solaris/native/java/net/net_util_md.c b/jdk/src/solaris/native/java/net/net_util_md.c
+index bd0bd8c2c9..4c021aea4d 100644
+--- a/jdk/src/solaris/native/java/net/net_util_md.c
++++ b/jdk/src/solaris/native/java/net/net_util_md.c
+@@ -662,7 +662,7 @@ struct localinterface {
+ 
+ static struct localinterface *localifs = 0;
+ static int localifsSize = 0;    /* size of array */
+-static int nifs = 0;            /* number of entries used in array */
++static int nifs = -1; /* number of entries used in array */
+ 
+ /* not thread safe: make sure called once from one thread */
+ 
+@@ -674,6 +674,10 @@ static void initLocalIfs () {
+     int index, x1, x2, x3;
+     unsigned int u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,ua,ub,uc,ud,ue,uf;
+ 
++    if (nifs >= 0)
++	    return ;
++    nifs = 0;
++
+     if ((f = fopen("/proc/net/if_inet6", "r")) == NULL) {
+         return ;
+     }
+@@ -702,7 +706,7 @@ static void initLocalIfs () {
+             localifs = (struct localinterface *) realloc (
+                         localifs, sizeof (struct localinterface)* (localifsSize+5));
+             if (localifs == 0) {
+-                nifs = 0;
++                nifs = -1;
+                 fclose (f);
+                 return;
+             }
+@@ -725,9 +729,7 @@ static void initLocalIfs () {
+ static int getLocalScopeID (char *addr) {
+     struct localinterface *lif;
+     int i;
+-    if (localifs == 0) {
+-        initLocalIfs();
+-    }
++    initLocalIfs();
+     for (i=0, lif=localifs; i<nifs; i++, lif++) {
+         if (memcmp (addr, lif->localaddr, 16) == 0) {
+             return lif->index;
+diff --git a/jdk/src/solaris/native/java/net/net_util_md.h b/jdk/src/solaris/native/java/net/net_util_md.h
+index a48446de9c..d0b61a6ba1 100644
+--- a/jdk/src/solaris/native/java/net/net_util_md.h
++++ b/jdk/src/solaris/native/java/net/net_util_md.h
+@@ -33,7 +33,11 @@
+ #include <unistd.h>
+ 
+ #ifndef USE_SELECT
+-#include <sys/poll.h>
++#ifndef MUSL_LIBC
++  #include <sys/poll.h>
++#else
++  #include <poll.h>
++#endif
+ #endif
+ 
+ 
+diff --git a/jdk/src/solaris/native/sun/nio/ch/DevPollArrayWrapper.c b/jdk/src/solaris/native/sun/nio/ch/DevPollArrayWrapper.c
+index 6860a167bb..b581508cf4 100644
+--- a/jdk/src/solaris/native/sun/nio/ch/DevPollArrayWrapper.c
++++ b/jdk/src/solaris/native/sun/nio/ch/DevPollArrayWrapper.c
+@@ -28,10 +28,15 @@
+ #include "jvm.h"
+ #include "jlong.h"
+ #include "sun_nio_ch_DevPollArrayWrapper.h"
+-#include <sys/poll.h>
+ #include <unistd.h>
+ #include <sys/time.h>
+ 
++#ifndef MUSL_LIBC
++#include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
++
+ #ifdef  __cplusplus
+ extern "C" {
+ #endif
+diff --git a/jdk/src/solaris/native/sun/nio/ch/NativeThread.c b/jdk/src/solaris/native/sun/nio/ch/NativeThread.c
+index 5e2a78b7af..b512b10aed 100644
+--- a/jdk/src/solaris/native/sun/nio/ch/NativeThread.c
++++ b/jdk/src/solaris/native/sun/nio/ch/NativeThread.c
+@@ -34,9 +34,13 @@
+ 
+ #ifdef __linux__
+   #include <pthread.h>
+-  #include <sys/signal.h>
++  #ifndef MUSL_LIBC
++    #include <sys/signal.h>
++  #else
++    #include <signal.h>
++  #endif
+   /* Also defined in net/linux_close.c */
+-  #define INTERRUPT_SIGNAL (__SIGRTMAX - 2)
++  #define INTERRUPT_SIGNAL (SIGRTMAX - 2)
+ #elif __solaris__
+   #include <thread.h>
+   #include <signal.h>
+diff --git a/jdk/src/solaris/native/sun/nio/ch/Net.c b/jdk/src/solaris/native/sun/nio/ch/Net.c
+index fcb6197c1d..37f04646bd 100644
+--- a/jdk/src/solaris/native/sun/nio/ch/Net.c
++++ b/jdk/src/solaris/native/sun/nio/ch/Net.c
+@@ -23,7 +23,12 @@
+  * questions.
+  */
+ 
++#ifndef MUSL_LIBC
+ #include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
++
+ #include <sys/types.h>
+ #include <sys/socket.h>
+ #include <string.h>
+diff --git a/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c b/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c
+index 375aaa4850..d2169095a2 100644
+--- a/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c
++++ b/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c
+@@ -32,9 +32,14 @@
+ #include <dlfcn.h>
+ #include <sys/types.h>
+ #include <sys/socket.h>
+-#include <sys/poll.h>
+ #include <sys/inotify.h>
+ 
++#ifndef MUSL_LIBC
++#include <sys/poll.h>
++#else
++#include <poll.h>
++#endif
++
+ #include "sun_nio_fs_LinuxWatchService.h"
+ 
+ static void throwUnixException(JNIEnv* env, int errnum) {
+diff --git a/jdk/src/solaris/native/sun/tools/attach/LinuxVirtualMachine.c b/jdk/src/solaris/native/sun/tools/attach/LinuxVirtualMachine.c
+index 6017308d0b..a583b4bae8 100644
+--- a/jdk/src/solaris/native/sun/tools/attach/LinuxVirtualMachine.c
++++ b/jdk/src/solaris/native/sun/tools/attach/LinuxVirtualMachine.c
+@@ -195,6 +195,9 @@ JNIEXPORT void JNICALL Java_sun_tools_attach_LinuxVirtualMachine_connect
+ JNIEXPORT jboolean JNICALL Java_sun_tools_attach_LinuxVirtualMachine_isLinuxThreads
+   (JNIEnv *env, jclass cls)
+ {
++# ifdef MUSL_LIBC
++   return JNI_FALSE;
++# else
+ # ifndef _CS_GNU_LIBPTHREAD_VERSION
+ # define _CS_GNU_LIBPTHREAD_VERSION 3
+ # endif
+@@ -222,6 +225,7 @@ JNIEXPORT jboolean JNICALL Java_sun_tools_attach_LinuxVirtualMachine_isLinuxThre
+     res = (jboolean)(strstr(s, "NPTL") == NULL);
+     free(s);
+     return res;
++# endif
+ }
+ 
+ /*
+diff --git a/jdk/src/solaris/native/sun/xawt/XToolkit.c b/jdk/src/solaris/native/sun/xawt/XToolkit.c
+index 24557cba41..1123389585 100644
+--- a/jdk/src/solaris/native/sun/xawt/XToolkit.c
++++ b/jdk/src/solaris/native/sun/xawt/XToolkit.c
+@@ -27,9 +27,6 @@
+ #include <X11/Xutil.h>
+ #include <X11/Xos.h>
+ #include <X11/Xatom.h>
+-#ifdef __linux__
+-#include <execinfo.h>
+-#endif
+ 
+ #include <jvm.h>
+ #include <jni.h>
+@@ -796,26 +793,6 @@ JNIEXPORT jstring JNICALL Java_sun_awt_X11_XToolkit_getEnv
+     return ret;
+ }
+ 
+-#ifdef __linux__
+-void print_stack(void)
+-{
+-  void *array[10];
+-  size_t size;
+-  char **strings;
+-  size_t i;
+-
+-  size = backtrace (array, 10);
+-  strings = backtrace_symbols (array, size);
+-
+-  fprintf (stderr, "Obtained %zd stack frames.\n", size);
+-
+-  for (i = 0; i < size; i++)
+-     fprintf (stderr, "%s\n", strings[i]);
+-
+-  free (strings);
+-}
+-#endif
+-
+ Window get_xawt_root_shell(JNIEnv *env) {
+   static jclass classXRootWindow = NULL;
+   static jmethodID methodGetXRootWindow = NULL;
+diff --git a/jdk/src/solaris/transport/socket/socket_md.c b/jdk/src/solaris/transport/socket/socket_md.c
+index 33e062e087..e4f6b56ad4 100644
+--- a/jdk/src/solaris/transport/socket/socket_md.c
++++ b/jdk/src/solaris/transport/socket/socket_md.c
+@@ -34,10 +34,14 @@
+ #include <string.h>
+ #include <sys/time.h>
+ #ifdef __solaris__
+-#include <thread.h>
++  #include <thread.h>
+ #else
+-#include <pthread.h>
+-#include <sys/poll.h>
++  #include <pthread.h>
++  #ifndef MUSL_LIBC
++    #include <sys/poll.h>
++  #else
++    #include <poll.h>
++  #endif
+ #endif
+ 
+ #include "socket_md.h"
+-- 
+2.39.0
diff --git a/patches/alpine-jdk8u/0006-Change-glibc_version-to-libc_version.patch b/patches/alpine-jdk8u/0006-Change-glibc_version-to-libc_version.patch
deleted file mode 100644
index 6851a51..0000000
--- a/patches/alpine-jdk8u/0006-Change-glibc_version-to-libc_version.patch
+++ /dev/null
@@ -1,143 +0,0 @@
-From 32eabea07e0fbb17c43ac4fc5603c920f877df88 Mon Sep 17 00:00:00 2001
-From: Stephanie Crater <scrater@microsoft.com>
-Date: Mon, 7 Mar 2022 16:58:38 -0800
-Subject: [PATCH] Change glibc_version to libc_version
-
----
- hotspot/src/os/linux/vm/os_linux.cpp | 27 ++++++++++++++++++++-------
- hotspot/src/os/linux/vm/os_linux.hpp |  6 +++---
- 2 files changed, 23 insertions(+), 10 deletions(-)
-
-diff --git a/hotspot/src/os/linux/vm/os_linux.cpp b/hotspot/src/os/linux/vm/os_linux.cpp
-index 2d3880b363..156d0eef43 100644
---- a/hotspot/src/os/linux/vm/os_linux.cpp
-+++ b/hotspot/src/os/linux/vm/os_linux.cpp
-@@ -95,7 +95,6 @@
- # include <string.h>
- # include <syscall.h>
- # include <sys/sysinfo.h>
--# include <gnu/libc-version.h>
- # include <sys/ipc.h>
- # include <sys/shm.h>
- # include <link.h>
-@@ -103,6 +102,10 @@
- # include <inttypes.h>
- # include <sys/ioctl.h>
- 
-+#ifndef MUSL_LIBC
-+#include <gnu/libc-version.h>
-+#endif
-+
- PRAGMA_FORMAT_MUTE_WARNINGS_FOR_GCC
- 
- #ifndef _GNU_SOURCE
-@@ -144,7 +147,7 @@ const int os::Linux::_vm_default_page_size = (8 * K);
- bool os::Linux::_is_floating_stack = false;
- bool os::Linux::_is_NPTL = false;
- bool os::Linux::_supports_fast_thread_cpu_time = false;
--const char * os::Linux::_glibc_version = NULL;
-+const char * os::Linux::_libc_version = NULL;
- const char * os::Linux::_libpthread_version = NULL;
- pthread_condattr_t os::Linux::_condattr[1];
- 
-@@ -581,6 +584,15 @@ void os::Linux::hotspot_sigmask(Thread* thread) {
- // detecting pthread library
- 
- void os::Linux::libpthread_init() {
-+#ifdef MUSL_LIBC
-+  // Hard code Alpine Linux supported musl compatible settings.
-+  // confstr() from musl libc returns EINVAL for
-+  // _CS_GNU_LIBC_VERSION and _CS_GNU_LIBPTHREAD_VERSION
-+  os::Linux::set_libc_version("musl - unknown");
-+  os::Linux::set_libpthread_version("musl - unknown");
-+  os::Linux::set_is_NPTL();
-+  os::Linux::set_is_floating_stack();
-+#else
-   // Save glibc and pthread version strings. Note that _CS_GNU_LIBC_VERSION
-   // and _CS_GNU_LIBPTHREAD_VERSION are supported in glibc >= 2.3.2. Use a
-   // generic name for earlier versions.
-@@ -596,13 +608,13 @@ void os::Linux::libpthread_init() {
-   if (n > 0) {
-      char *str = (char *)malloc(n, mtInternal);
-      confstr(_CS_GNU_LIBC_VERSION, str, n);
--     os::Linux::set_glibc_version(str);
-+     os::Linux::set_libc_version(str);
-   } else {
-      // _CS_GNU_LIBC_VERSION is not supported, try gnu_get_libc_version()
-      static char _gnu_libc_version[32];
-      jio_snprintf(_gnu_libc_version, sizeof(_gnu_libc_version),
-               "glibc %s %s", gnu_get_libc_version(), gnu_get_libc_release());
--     os::Linux::set_glibc_version(_gnu_libc_version);
-+     os::Linux::set_libc_version(_gnu_libc_version);
-   }
- 
-   n = confstr(_CS_GNU_LIBPTHREAD_VERSION, NULL, 0);
-@@ -615,7 +627,7 @@ void os::Linux::libpthread_init() {
-      // So sysconf(_SC_THREAD_THREADS_MAX) will return a positive value.
-      // On the other hand, NPTL does not have such a limit, sysconf()
-      // will return -1 and errno is not changed. Check if it is really NPTL.
--     if (strcmp(os::Linux::glibc_version(), "glibc 2.3.2") == 0 &&
-+     if (strcmp(os::Linux::libc_version(), "glibc 2.3.2") == 0 &&
-          strstr(str, "NPTL") &&
-          sysconf(_SC_THREAD_THREADS_MAX) > 0) {
-        free(str);
-@@ -639,6 +651,7 @@ void os::Linux::libpthread_init() {
-   if (os::Linux::is_NPTL() || os::Linux::supports_variable_stack_size()) {
-      os::Linux::set_is_floating_stack();
-   }
-+#endif
- }
- 
- /////////////////////////////////////////////////////////////////////////////
-@@ -2269,7 +2282,7 @@ void os::Linux::print_distro_info(outputStream* st) {
- void os::Linux::print_libversion_info(outputStream* st) {
-   // libc, pthread
-   st->print("libc:");
--  st->print("%s ", os::Linux::glibc_version());
-+  st->print("%s ", os::Linux::libc_version());
-   st->print("%s ", os::Linux::libpthread_version());
-   if (os::Linux::is_LinuxThreads()) {
-      st->print("(%s stack)", os::Linux::is_floating_stack() ? "floating" : "fixed");
-@@ -5186,7 +5199,7 @@ jint os::init_2(void)
-   Linux::libpthread_init();
-   if (PrintMiscellaneous && (Verbose || WizardMode)) {
-      tty->print_cr("[HotSpot is running with %s, %s(%s)]\n",
--          Linux::glibc_version(), Linux::libpthread_version(),
-+          Linux::libc_version(), Linux::libpthread_version(),
-           Linux::is_floating_stack() ? "floating stack" : "fixed stack");
-   }
- 
-diff --git a/hotspot/src/os/linux/vm/os_linux.hpp b/hotspot/src/os/linux/vm/os_linux.hpp
-index 79a9f39ab7..649caba76f 100644
---- a/hotspot/src/os/linux/vm/os_linux.hpp
-+++ b/hotspot/src/os/linux/vm/os_linux.hpp
-@@ -61,7 +61,7 @@ class Linux {
-   static address   _initial_thread_stack_bottom;
-   static uintptr_t _initial_thread_stack_size;
- 
--  static const char *_glibc_version;
-+  static const char *_libc_version;
-   static const char *_libpthread_version;
- 
-   static bool _is_floating_stack;
-@@ -90,7 +90,7 @@ class Linux {
-   static int commit_memory_impl(char* addr, size_t bytes,
-                                 size_t alignment_hint, bool exec);
- 
--  static void set_glibc_version(const char *s)      { _glibc_version = s; }
-+  static void set_libc_version(const char *s)       { _libc_version = s; }
-   static void set_libpthread_version(const char *s) { _libpthread_version = s; }
- 
-   static bool supports_variable_stack_size();
-@@ -181,7 +181,7 @@ class Linux {
-   static bool chained_handler(int sig, siginfo_t* siginfo, void* context);
- 
-   // GNU libc and libpthread version strings
--  static const char *glibc_version()          { return _glibc_version; }
-+  static const char *libc_version()           { return _libc_version; }
-   static const char *libpthread_version()     { return _libpthread_version; }
- 
-   // NPTL or LinuxThreads?
--- 
-2.52.0
-
diff --git a/patches/alpine-jdk8u/0007-Don-t-build-SA-if-using-musl-libc.patch b/patches/alpine-jdk8u/0007-Don-t-build-SA-if-using-musl-libc.patch
deleted file mode 100644
index c44ed5d..0000000
--- a/patches/alpine-jdk8u/0007-Don-t-build-SA-if-using-musl-libc.patch
+++ /dev/null
@@ -1,92 +0,0 @@
-From 5f57a1ed5a9dc6af40663cfe923ce98792d29546 Mon Sep 17 00:00:00 2001
-From: Stephanie Crater <scrater@microsoft.com>
-Date: Mon, 7 Mar 2022 17:21:52 -0800
-Subject: [PATCH] Don't build SA if using musl libc
-
----
- common/autoconf/jdk-options.m4           | 3 +++
- hotspot/make/linux/makefiles/defs.make   | 8 ++++++++
- hotspot/make/linux/makefiles/sa.make     | 4 +++-
- hotspot/make/linux/makefiles/saproc.make | 3 +++
- 4 files changed, 17 insertions(+), 1 deletion(-)
-
-diff --git a/common/autoconf/jdk-options.m4 b/common/autoconf/jdk-options.m4
-index 42aeb7bd61..e46cb823ef 100644
---- a/common/autoconf/jdk-options.m4
-+++ b/common/autoconf/jdk-options.m4
-@@ -152,6 +152,9 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_JVM_VARIANTS],
-   AC_SUBST(JVM_VARIANT_CORE)
- 
-   INCLUDE_SA=true
-+  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
-+    INCLUDE_SA=false
-+  fi
-   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
-     INCLUDE_SA=false
-   fi
-diff --git a/hotspot/make/linux/makefiles/defs.make b/hotspot/make/linux/makefiles/defs.make
-index ec414639d2..5d05825300 100644
---- a/hotspot/make/linux/makefiles/defs.make
-+++ b/hotspot/make/linux/makefiles/defs.make
-@@ -305,6 +305,9 @@ endif
- 
- # Serviceability Binaries
- # No SA Support for PPC, IA64, ARM or zero
-+# or if thread_db.h missing (musl)
-+
-+ifneq ($(wildcard /usr/include/thread_db.h),)
- ADD_SA_BINARIES/x86   = $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.$(LIBRARY_SUFFIX) \
-                         $(EXPORT_LIB_DIR)/sa-jdi.jar
- ADD_SA_BINARIES/sparc = $(EXPORT_JRE_LIB_ARCH_DIR)/libsaproc.$(LIBRARY_SUFFIX) \
-@@ -324,6 +327,11 @@ ifeq ($(ENABLE_FULL_DEBUG_SYMBOLS),1)
-     endif
-   endif
- endif
-+else
-+ADD_SA_BINARIES/x86     =
-+ADD_SA_BINARIES/sparc   =
-+ADD_SA_BINARIES/aarch64 =
-+endif
- ADD_SA_BINARIES/ppc   =
- ADD_SA_BINARIES/ia64  =
- ADD_SA_BINARIES/arm   =
-diff --git a/hotspot/make/linux/makefiles/sa.make b/hotspot/make/linux/makefiles/sa.make
-index cdcb16a1a3..5c2f661ee1 100644
---- a/hotspot/make/linux/makefiles/sa.make
-+++ b/hotspot/make/linux/makefiles/sa.make
-@@ -59,9 +59,11 @@ SA_PROPERTIES = $(SA_CLASSDIR)/sa.properties
- 
- # if $(AGENT_DIR) does not exist, we don't build SA
- # also, we don't build SA on Itanium or zero.
-+# check for thread_db.h too (musl does not have it).
- 
- all: 
--	if [ -d $(AGENT_DIR) -a "$(SRCARCH)" != "ia64" \
-+if [ -d $(AGENT_DIR) -a -f /usr/include/thread_db.h \
-+             -a "$(SRCARCH)" != "ia64" \
-              -a "$(SRCARCH)" != "zero" ] ; then \
- 	   $(MAKE) -f sa.make $(GENERATED)/sa-jdi.jar; \
- 	fi
-diff --git a/hotspot/make/linux/makefiles/saproc.make b/hotspot/make/linux/makefiles/saproc.make
-index ffc0ec5ce5..732c7614d6 100644
---- a/hotspot/make/linux/makefiles/saproc.make
-+++ b/hotspot/make/linux/makefiles/saproc.make
-@@ -66,12 +66,15 @@ endif
- 
- # if $(AGENT_DIR) does not exist, we don't build SA
- # also, we don't build SA on Itanium or zero.
-+# check for thread_db.h too (musl does not have it).
- 
-+ifneq ($(wildcard /usr/include/thread_db.h),)
- ifneq ($(wildcard $(AGENT_DIR)),)
- ifneq ($(filter-out ia64 zero,$(SRCARCH)),)
-   BUILDLIBSAPROC = $(LIBSAPROC)
- endif
- endif
-+endif
- 
- ifneq ($(ALT_SASRCDIR),)
- ALT_SAINCDIR=-I$(ALT_SASRCDIR) -DALT_SASRCDIR
--- 
-2.52.0
-
diff --git a/patches/alpine-jdk8u/0008-Apply-Alpine-s-patches-for-musl-libc.patch b/patches/alpine-jdk8u/0008-Apply-Alpine-s-patches-for-musl-libc.patch
deleted file mode 100644
index 4a22e3a..0000000
--- a/patches/alpine-jdk8u/0008-Apply-Alpine-s-patches-for-musl-libc.patch
+++ /dev/null
@@ -1,360 +0,0 @@
-From 8937a62908a651a24d41a9bf46fc2928cbb0f71b Mon Sep 17 00:00:00 2001
-From: Stephanie Crater <scrater@microsoft.com>
-Date: Mon, 7 Mar 2022 16:46:47 -0800
-Subject: [PATCH] Apply Alpine's patches for musl libc
-
----
- hotspot/src/os/linux/vm/jvm_linux.cpp         |  2 +
- hotspot/src/os/linux/vm/os_linux.cpp          | 13 ++++-
- .../linux_aarch64/vm/os_linux_aarch64.cpp     |  7 ++-
- .../src/os_cpu/linux_x86/vm/os_linux_x86.cpp  | 10 +++-
- .../linux_x86/vm/threadLS_linux_x86.hpp       |  2 +
- .../vm/utilities/globalDefinitions_gcc.hpp    |  2 +-
- jdk/src/solaris/bin/java_md_solinux.c         |  4 ++
- .../solaris/native/java/lang/UNIXProcess_md.c |  8 +++
- jdk/src/solaris/native/java/lang/childproc.c  | 57 ++++++++++++++++++-
- .../native/java/net/Inet4AddressImpl.c        |  2 +-
- jdk/src/solaris/native/java/net/net_util_md.c | 12 ++--
- .../sun/tools/attach/LinuxVirtualMachine.c    |  4 ++
- 12 files changed, 111 insertions(+), 12 deletions(-)
-
-diff --git a/hotspot/src/os/linux/vm/jvm_linux.cpp b/hotspot/src/os/linux/vm/jvm_linux.cpp
-index ba84788a1b..c22281f7ca 100644
---- a/hotspot/src/os/linux/vm/jvm_linux.cpp
-+++ b/hotspot/src/os/linux/vm/jvm_linux.cpp
-@@ -154,7 +154,9 @@ struct siglabel siglabels[] = {
- #ifdef SIGSTKFLT
-   "STKFLT",     SIGSTKFLT,      /* Stack fault.  */
- #endif
-+#ifdef SIGCLD
-   "CLD",        SIGCLD,         /* Same as SIGCHLD (System V).  */
-+#endif
-   "CHLD",       SIGCHLD,        /* Child status has changed (POSIX).  */
-   "CONT",       SIGCONT,        /* Continue (POSIX).  */
-   "STOP",       SIGSTOP,        /* Stop, unblockable (POSIX).  */
-diff --git a/hotspot/src/os/linux/vm/os_linux.cpp b/hotspot/src/os/linux/vm/os_linux.cpp
-index 156d0eef43..88a06ffc06 100644
---- a/hotspot/src/os/linux/vm/os_linux.cpp
-+++ b/hotspot/src/os/linux/vm/os_linux.cpp
-@@ -809,7 +809,7 @@ static void *java_start(Thread *thread) {
-   // processors with hyperthreading technology.
-   static int counter = 0;
-   int pid = os::current_process_id();
--  alloca(((pid ^ counter++) & 7) * 128);
-+  void *tmp = alloca(((pid ^ counter++) & 7) * 128);
- 
-   ThreadLocalStorage::set_thread(thread);
- 
-@@ -2987,6 +2987,14 @@ extern "C" JNIEXPORT void numa_warn(int number, char *where, ...) { }
- extern "C" JNIEXPORT void numa_error(char *where) { }
- extern "C" JNIEXPORT int fork1() { return fork(); }
- 
-+#ifdef MUSL_LIBC
-+  // dlvsym is not a part of POSIX and musl libc doesn't implement it.
-+  static void *dlvsym(void *handle, const char *name, const char *ver)
-+  {
-+    return dlsym(handle, name);
-+  }
-+#endif
-+
- // Handle request to load libnuma symbol version 1.1 (API v1). If it fails
- // load symbol from base version instead.
- void* os::Linux::libnuma_dlsym(void* handle, const char *name) {
-@@ -5009,7 +5017,8 @@ void os::Linux::check_signal_handler(int sig) {
-   }
- 
-   if (thisHandler != jvmHandler) {
--    tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
-+    if(exception_name(sig, buf, O_BUFLEN))
-+      tty->print("Warning: %s handler ", exception_name(sig, buf, O_BUFLEN));
-     tty->print("expected:%s", get_signal_handler_name(jvmHandler, buf, O_BUFLEN));
-     tty->print_cr("  found:%s", get_signal_handler_name(thisHandler, buf, O_BUFLEN));
-     // No need to check this sig any longer
-diff --git a/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp b/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
-index 82e36d27f8..cf476a0b27 100644
---- a/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
-+++ b/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
-@@ -72,7 +72,12 @@
- # include <pwd.h>
- # include <poll.h>
- # include <ucontext.h>
--# include <fpu_control.h>
-+
-+#ifdef MUSL_LIBC
-+#include <fpu_control.h>
-+#else
-+#include <linux/types.h>  /* provides __u64 */
-+#endif
- 
- #define REG_FP 29
- 
-diff --git a/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp b/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp
-index 65c3165ca1..5505e573ff 100644
---- a/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp
-+++ b/hotspot/src/os_cpu/linux_x86/vm/os_linux_x86.cpp
-@@ -72,7 +72,10 @@
- # include <pwd.h>
- # include <poll.h>
- # include <ucontext.h>
--# include <fpu_control.h>
-+
-+#ifndef MUSL_LIBC
-+#include <fpu_control.h>
-+#endif
- 
- #ifdef AMD64
- #define REG_SP REG_RSP
-@@ -544,6 +547,11 @@ JVM_handle_linux_signal(int sig,
-   return true; // Mute compiler
- }
- 
-+#ifdef MUSL_LIBC
-+#define _FPU_GETCW(cw) __asm__ __volatile__ ("fnstcw %0" : "=m" (*&cw))
-+#define _FPU_SETCW(cw) __asm__ __volatile__ ("fldcw %0" : : "m" (*&cw))
-+#endif
-+
- void os::Linux::init_thread_fpu_state(void) {
- #ifndef AMD64
-   // set fpu to 53 bit precision
-diff --git a/hotspot/src/os_cpu/linux_x86/vm/threadLS_linux_x86.hpp b/hotspot/src/os_cpu/linux_x86/vm/threadLS_linux_x86.hpp
-index f3f2f26f88..00b472693a 100644
---- a/hotspot/src/os_cpu/linux_x86/vm/threadLS_linux_x86.hpp
-+++ b/hotspot/src/os_cpu/linux_x86/vm/threadLS_linux_x86.hpp
-@@ -32,7 +32,9 @@
-   // map stack pointer to thread pointer - see notes in threadLS_linux_x86.cpp
-   #define SP_BITLENGTH  32
-   #define PAGE_SHIFT    12
-+  #if !defined(MUSL_LIBC) || !defined(PAGE_SIZE)
-   #define PAGE_SIZE     (1UL << PAGE_SHIFT)
-+  #endif
-   static Thread* _sp_map[1UL << (SP_BITLENGTH - PAGE_SHIFT)];
- 
- public:
-diff --git a/hotspot/src/share/vm/utilities/globalDefinitions_gcc.hpp b/hotspot/src/share/vm/utilities/globalDefinitions_gcc.hpp
-index 5760eb2fab..be1e4dbce0 100644
---- a/hotspot/src/share/vm/utilities/globalDefinitions_gcc.hpp
-+++ b/hotspot/src/share/vm/utilities/globalDefinitions_gcc.hpp
-@@ -235,7 +235,7 @@ inline int g_isnan(double f) { return isnand(f); }
- #elif defined(__APPLE__)
- inline int g_isnan(double f) { return isnan(f); }
- #elif defined(LINUX) || defined(_ALLBSD_SOURCE)
--inline int g_isnan(float  f) { return isnanf(f); }
-+inline int g_isnan(float  f) { return isnan(f); }
- inline int g_isnan(double f) { return isnan(f); }
- #else
- #error "missing platform-specific definition here"
-diff --git a/jdk/src/solaris/bin/java_md_solinux.c b/jdk/src/solaris/bin/java_md_solinux.c
-index a96713757d..162b50073b 100644
---- a/jdk/src/solaris/bin/java_md_solinux.c
-+++ b/jdk/src/solaris/bin/java_md_solinux.c
-@@ -292,6 +292,10 @@ RequiresSetenv(int wanted, const char *jvmpath) {
-     char *dmllp = NULL;
-     char *p; /* a utility pointer */
- 
-+#ifdef MUSL_LIBC
-+    return JNI_TRUE;
-+#endif
-+
- #ifdef AIX
-     /* We always have to set the LIBPATH on AIX because ld doesn't support $ORIGIN. */
-     return JNI_TRUE;
-diff --git a/jdk/src/solaris/native/java/lang/UNIXProcess_md.c b/jdk/src/solaris/native/java/lang/UNIXProcess_md.c
-index 9b510ad3a9..ad233a2a76 100644
---- a/jdk/src/solaris/native/java/lang/UNIXProcess_md.c
-+++ b/jdk/src/solaris/native/java/lang/UNIXProcess_md.c
-@@ -550,7 +550,11 @@ static pid_t
- startChild(JNIEnv *env, jobject process, ChildStuff *c, const char *helperpath) {
-     switch (c->mode) {
-       case MODE_VFORK:
-+// use regular fork when running on musl
-+// this should fix deadlocks on aarch64
-+#ifndef MUSL_LIBC
-         return vforkChild(c);
-+#endif
-       case MODE_FORK:
-         return forkChild(c);
- #if defined(__solaris__) || defined(_ALLBSD_SOURCE) || defined(_AIX)
-@@ -649,8 +653,12 @@ Java_java_lang_UNIXProcess_forkAndExec(JNIEnv *env,
-     if (resultPid < 0) {
-         switch (c->mode) {
-           case MODE_VFORK:
-+// use regular fork when running on musl
-+// this should fix deadlocks on aarch64
-+#ifndef MUSL_LIBC
-             throwIOException(env, errno, "vfork failed");
-             break;
-+#endif
-           case MODE_FORK:
-             throwIOException(env, errno, "fork failed");
-             break;
-diff --git a/jdk/src/solaris/native/java/lang/childproc.c b/jdk/src/solaris/native/java/lang/childproc.c
-index c0045d5371..2d20db6185 100644
---- a/jdk/src/solaris/native/java/lang/childproc.c
-+++ b/jdk/src/solaris/native/java/lang/childproc.c
-@@ -23,7 +23,6 @@
-  * questions.
-  */
- 
--#include <dirent.h>
- #include <errno.h>
- #include <fcntl.h>
- #include <stdlib.h>
-@@ -31,6 +30,12 @@
- #include <unistd.h>
- #include <limits.h>
- 
-+#ifndef MUSL_LIBC
-+#include <dirent.h>
-+#else
-+#include <poll.h>
-+#endif
-+
- #include "childproc.h"
- 
- const char * const *parentPathv;
-@@ -57,6 +62,8 @@ closeSafely(int fd)
-     return (fd == -1) ? 0 : close(fd);
- }
- 
-+#ifndef MUSL_LIBC
-+
- int
- isAsciiDigit(char c)
- {
-@@ -115,6 +122,54 @@ closeDescriptors(void)
-     return 1;
- }
- 
-+#else // Musl
-+
-+int
-+closeDescriptors(void)
-+{
-+    int from_fd = FAIL_FILENO + 1;
-+    struct pollfd pfds[1024];
-+    int i, total, nclosed = 0;
-+    int max_fd = sysconf(_SC_OPEN_MAX);
-+
-+    if (max_fd < 0)
-+        return 0;
-+
-+    /* init events */
-+    total = max_fd - from_fd;
-+    for (i = 0; i < (total < 1024 ? total : 1024); i++) {
-+        pfds[i].events = 0;
-+    }
-+
-+    while (from_fd < max_fd) {
-+        int nfds, r = 0;
-+
-+        total = max_fd - from_fd;
-+        nfds =  total < 1024 ? total : 1024;
-+
-+        for (i = 0; i < nfds; i++)
-+            pfds[i].fd = from_fd + i;
-+
-+        do {
-+            r = poll(pfds, nfds, 0);
-+        } while (r == -1 && errno == EINTR);
-+
-+        if (r < 0)
-+            return 0;
-+
-+
-+        for (i = 0; i < nfds; i++)
-+            if (pfds[i].revents != POLLNVAL) {
-+                nclosed++;
-+                close(pfds[i].fd);
-+            }
-+        from_fd += nfds;
-+    }
-+    return 1;
-+}
-+
-+#endif
-+
- int
- moveDescriptor(int fd_from, int fd_to)
- {
-diff --git a/jdk/src/solaris/native/java/net/Inet4AddressImpl.c b/jdk/src/solaris/native/java/net/Inet4AddressImpl.c
-index 7e193a9319..dba1fa689e 100644
---- a/jdk/src/solaris/native/java/net/Inet4AddressImpl.c
-+++ b/jdk/src/solaris/native/java/net/Inet4AddressImpl.c
-@@ -47,7 +47,7 @@
- 
- #include "java_net_Inet4AddressImpl.h"
- 
--#if defined(__GLIBC__) || (defined(__FreeBSD__) && (__FreeBSD_version >= 601104))
-+#if defined(__linux__) || (defined(__FreeBSD__) && (__FreeBSD_version >= 601104))
- #define HAS_GLIBC_GETHOSTBY_R   1
- #endif
- 
-diff --git a/jdk/src/solaris/native/java/net/net_util_md.c b/jdk/src/solaris/native/java/net/net_util_md.c
-index bd0bd8c2c9..4c021aea4d 100644
---- a/jdk/src/solaris/native/java/net/net_util_md.c
-+++ b/jdk/src/solaris/native/java/net/net_util_md.c
-@@ -662,7 +662,7 @@ struct localinterface {
- 
- static struct localinterface *localifs = 0;
- static int localifsSize = 0;    /* size of array */
--static int nifs = 0;            /* number of entries used in array */
-+static int nifs = -1; /* number of entries used in array */
- 
- /* not thread safe: make sure called once from one thread */
- 
-@@ -674,6 +674,10 @@ static void initLocalIfs () {
-     int index, x1, x2, x3;
-     unsigned int u0,u1,u2,u3,u4,u5,u6,u7,u8,u9,ua,ub,uc,ud,ue,uf;
- 
-+    if (nifs >= 0)
-+	    return ;
-+    nifs = 0;
-+
-     if ((f = fopen("/proc/net/if_inet6", "r")) == NULL) {
-         return ;
-     }
-@@ -702,7 +706,7 @@ static void initLocalIfs () {
-             localifs = (struct localinterface *) realloc (
-                         localifs, sizeof (struct localinterface)* (localifsSize+5));
-             if (localifs == 0) {
--                nifs = 0;
-+                nifs = -1;
-                 fclose (f);
-                 return;
-             }
-@@ -725,9 +729,7 @@ static void initLocalIfs () {
- static int getLocalScopeID (char *addr) {
-     struct localinterface *lif;
-     int i;
--    if (localifs == 0) {
--        initLocalIfs();
--    }
-+    initLocalIfs();
-     for (i=0, lif=localifs; i<nifs; i++, lif++) {
-         if (memcmp (addr, lif->localaddr, 16) == 0) {
-             return lif->index;
-diff --git a/jdk/src/solaris/native/sun/tools/attach/LinuxVirtualMachine.c b/jdk/src/solaris/native/sun/tools/attach/LinuxVirtualMachine.c
-index 6017308d0b..a583b4bae8 100644
---- a/jdk/src/solaris/native/sun/tools/attach/LinuxVirtualMachine.c
-+++ b/jdk/src/solaris/native/sun/tools/attach/LinuxVirtualMachine.c
-@@ -195,6 +195,9 @@ JNIEXPORT void JNICALL Java_sun_tools_attach_LinuxVirtualMachine_connect
- JNIEXPORT jboolean JNICALL Java_sun_tools_attach_LinuxVirtualMachine_isLinuxThreads
-   (JNIEnv *env, jclass cls)
- {
-+# ifdef MUSL_LIBC
-+   return JNI_FALSE;
-+# else
- # ifndef _CS_GNU_LIBPTHREAD_VERSION
- # define _CS_GNU_LIBPTHREAD_VERSION 3
- # endif
-@@ -222,6 +225,7 @@ JNIEXPORT jboolean JNICALL Java_sun_tools_attach_LinuxVirtualMachine_isLinuxThre
-     res = (jboolean)(strstr(s, "NPTL") == NULL);
-     free(s);
-     return res;
-+# endif
- }
- 
- /*
--- 
-2.52.0
-
diff --git a/patches/alpine-jdk8u/0009-Apply-Alpine-s-ppc-patch-for-musl-libc.patch b/patches/alpine-jdk8u/0009-Apply-Alpine-s-ppc-patch-for-musl-libc.patch
deleted file mode 100644
index add2b57..0000000
--- a/patches/alpine-jdk8u/0009-Apply-Alpine-s-ppc-patch-for-musl-libc.patch
+++ /dev/null
@@ -1,236 +0,0 @@
-From 1f5e05f38838733d576937108782cc3296bf7e10 Mon Sep 17 00:00:00 2001
-From: Stephanie Crater <scrater@microsoft.com>
-Date: Mon, 7 Mar 2022 16:12:23 -0800
-Subject: [PATCH] Apply Alpine's ppc patch for musl libc
-
----
- hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp | 22 ++++++++++
- .../src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp  | 42 +++++++++++++++++++
- .../os_cpu/linux_ppc/vm/thread_linux_ppc.cpp  | 13 ++++++
- 3 files changed, 77 insertions(+)
-
-diff --git a/hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp b/hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp
-index f661847b66..d40548f680 100644
---- a/hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp
-+++ b/hotspot/src/cpu/ppc/vm/macroAssembler_ppc.cpp
-@@ -1243,7 +1243,11 @@ bool MacroAssembler::is_load_from_polling_page(int instruction, void* ucontext,
-   // the safepoing polling page.
-   ucontext_t* uc = (ucontext_t*) ucontext;
-   // Set polling address.
-+#ifndef MUSL_LIBC
-   address addr = (address)uc->uc_mcontext.regs->gpr[ra] + (ssize_t)ds;
-+#else
-+  address addr = (address)uc->uc_mcontext.gp_regs[ra] + (ssize_t)ds;
-+#endif
-   if (polling_address_ptr != NULL) {
-     *polling_address_ptr = addr;
-   }
-@@ -1264,15 +1268,24 @@ bool MacroAssembler::is_memory_serialization(int instruction, JavaThread* thread
-     int rb = inv_rb_field(instruction);
- 
-     // look up content of ra and rb in ucontext
-+#ifndef MUSL_LIBC
-     address ra_val=(address)uc->uc_mcontext.regs->gpr[ra];
-     long rb_val=(long)uc->uc_mcontext.regs->gpr[rb];
-+#else
-+    address ra_val=(address)uc->uc_mcontext.gp_regs[ra];
-+    long rb_val=(long)uc->uc_mcontext.gp_regs[rb];
-+#endif
-     return os::is_memory_serialize_page(thread, ra_val+rb_val);
-   } else if (is_stw(instruction) || is_stwu(instruction)) {
-     int ra = inv_ra_field(instruction);
-     int d1 = inv_d1_field(instruction);
- 
-     // look up content of ra in ucontext
-+#ifndef MUSL_LIBC
-     address ra_val=(address)uc->uc_mcontext.regs->gpr[ra];
-+#else
-+    address ra_val=(address)uc->uc_mcontext.gp_regs[ra];
-+#endif
-     return os::is_memory_serialize_page(thread, ra_val+d1);
-   } else {
-     return false;
-@@ -1335,11 +1348,20 @@ address MacroAssembler::get_stack_bang_address(int instruction, void *ucontext)
-       || (is_stdu(instruction) && rs == 1)) {
-     int ds = inv_ds_field(instruction);
-     // return banged address
-+#ifndef MUSL_LIBC
-     return ds+(address)uc->uc_mcontext.regs->gpr[ra];
-+#else
-+    return ds+(address)uc->uc_mcontext.gp_regs[ra];
-+#endif
-   } else if (is_stdux(instruction) && rs == 1) {
-     int rb = inv_rb_field(instruction);
-+#ifndef MUSL_LIBC
-     address sp = (address)uc->uc_mcontext.regs->gpr[1];
-     long rb_val = (long)uc->uc_mcontext.regs->gpr[rb];
-+#else
-+    address sp = (address)uc->uc_mcontext.gp_regs[1];
-+    long rb_val = (long)uc->uc_mcontext.gp_regs[rb];
-+#endif
-     return ra != 1 || rb_val >= 0 ? NULL         // not a stack bang
-                                   : sp + rb_val; // banged address
-   }
-diff --git a/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp b/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp
-index 1fb993ec19..5ac8757a1f 100644
---- a/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp
-+++ b/hotspot/src/os_cpu/linux_ppc/vm/os_linux_ppc.cpp
-@@ -75,6 +75,9 @@
- # include <poll.h>
- # include <ucontext.h>
- 
-+#ifdef MUSL_LIBC
-+#include <asm/ptrace.h>
-+#endif
- 
- address os::current_stack_pointer() {
-   intptr_t* csp;
-@@ -110,11 +113,19 @@ address os::Linux::ucontext_get_pc(ucontext_t * uc) {
-   //   it because the volatile registers are not needed to make setcontext() work.
-   //   Hopefully it was zero'd out beforehand.
-   guarantee(uc->uc_mcontext.regs != NULL, "only use ucontext_get_pc in sigaction context");
-+#ifndef MUSL_LIBC
-   return (address)uc->uc_mcontext.regs->nip;
-+#else
-+  return (address)uc->uc_mcontext.gp_regs[PT_NIP];
-+#endif
- }
- 
- intptr_t* os::Linux::ucontext_get_sp(ucontext_t * uc) {
-+#ifndef MUSL_LIBC
-   return (intptr_t*)uc->uc_mcontext.regs->gpr[1/*REG_SP*/];
-+#else
-+  return (intptr_t*)uc->uc_mcontext.gp_regs[1/*REG_SP*/];
-+#endif
- }
- 
- intptr_t* os::Linux::ucontext_get_fp(ucontext_t * uc) {
-@@ -217,7 +228,11 @@ JVM_handle_linux_signal(int sig,
-   if (uc) {
-     address const pc = os::Linux::ucontext_get_pc(uc);
-     if (pc && StubRoutines::is_safefetch_fault(pc)) {
-+#ifndef MUSL_LIBC
-       uc->uc_mcontext.regs->nip = (unsigned long)StubRoutines::continuation_for_safefetch_fault(pc);
-+#else
-+      uc->uc_mcontext.gp_regs[PT_NIP] = (unsigned long)StubRoutines::continuation_for_safefetch_fault(pc);
-+#endif
-       return true;
-     }
-   }
-@@ -368,7 +383,11 @@ JVM_handle_linux_signal(int sig,
-           // continue at the next instruction after the faulting read. Returning
-           // garbage from this read is ok.
-           thread->set_pending_unsafe_access_error();
-+#ifndef MUSL_LIBC
-           uc->uc_mcontext.regs->nip = ((unsigned long)pc) + 4;
-+#else
-+          uc->uc_mcontext.gp_regs[PT_NIP] = ((unsigned long)pc) + 4;
-+#endif
-           return true;
-         }
-       }
-@@ -387,7 +406,11 @@ JVM_handle_linux_signal(int sig,
-         // continue at the next instruction after the faulting read. Returning
-         // garbage from this read is ok.
-         thread->set_pending_unsafe_access_error();
-+#ifndef MUSL_LIBC
-         uc->uc_mcontext.regs->nip = ((unsigned long)pc) + 4;
-+#else
-+        uc->uc_mcontext.gp_regs[PT_NIP] = ((unsigned long)pc) + 4;
-+#endif
-         return true;
-       }
-     }
-@@ -410,7 +433,11 @@ JVM_handle_linux_signal(int sig,
-   if (stub != NULL) {
-     // Save all thread context in case we need to restore it.
-     if (thread != NULL) thread->set_saved_exception_pc(pc);
-+#ifndef MUSL_LIBC
-     uc->uc_mcontext.regs->nip = (unsigned long)stub;
-+#else
-+    uc->uc_mcontext.gp_regs[PT_NIP] = (unsigned long)stub;
-+#endif
-     return true;
-   }
- 
-@@ -568,6 +595,7 @@ void os::print_context(outputStream *st, void *context) {
-   ucontext_t* uc = (ucontext_t*)context;
- 
-   st->print_cr("Registers:");
-+#ifndef MUSL_LIBC
-   st->print("pc =" INTPTR_FORMAT "  ", uc->uc_mcontext.regs->nip);
-   st->print("lr =" INTPTR_FORMAT "  ", uc->uc_mcontext.regs->link);
-   st->print("ctr=" INTPTR_FORMAT "  ", uc->uc_mcontext.regs->ctr);
-@@ -576,6 +604,16 @@ void os::print_context(outputStream *st, void *context) {
-     st->print("r%-2d=" INTPTR_FORMAT "  ", i, uc->uc_mcontext.regs->gpr[i]);
-     if (i % 3 == 2) st->cr();
-   }
-+#else // Musl
-+  st->print("pc =" INTPTR_FORMAT "  ", uc->uc_mcontext.gp_regs[PT_NIP]);
-+  st->print("lr =" INTPTR_FORMAT "  ", uc->uc_mcontext.gp_regs[PT_LNK]);
-+  st->print("ctr=" INTPTR_FORMAT "  ", uc->uc_mcontext.gp_regs[PT_CTR]);
-+  st->cr();
-+  for (int i = 0; i < 32; i++) {
-+    st->print("r%-2d=" INTPTR_FORMAT "  ", i, uc->uc_mcontext.gp_regs[i]);
-+    if (i % 3 == 2) st->cr();
-+  }
-+#endif
-   st->cr();
-   st->cr();
- 
-@@ -604,7 +642,11 @@ void os::print_register_info(outputStream *st, void *context) {
-   // this is only for the "general purpose" registers
-   for (int i = 0; i < 32; i++) {
-     st->print("r%-2d=", i);
-+#ifndef MUSL_LIBC
-     print_location(st, uc->uc_mcontext.regs->gpr[i]);
-+#else
-+    print_location(st, uc->uc_mcontext.gp_regs[i]);
-+#endif
-   }
-   st->cr();
- }
-diff --git a/hotspot/src/os_cpu/linux_ppc/vm/thread_linux_ppc.cpp b/hotspot/src/os_cpu/linux_ppc/vm/thread_linux_ppc.cpp
-index 802677f470..dd68a34549 100644
---- a/hotspot/src/os_cpu/linux_ppc/vm/thread_linux_ppc.cpp
-+++ b/hotspot/src/os_cpu/linux_ppc/vm/thread_linux_ppc.cpp
-@@ -27,6 +27,10 @@
- #include "runtime/frame.inline.hpp"
- #include "runtime/thread.hpp"
- 
-+#ifdef MUSL_LIBC
-+#include <asm/ptrace.h>
-+#endif
-+
- bool JavaThread::pd_get_top_frame_for_profiling(frame* fr_addr, void* ucontext, bool isInJava) {
-   assert(this->is_Java_thread(), "must be JavaThread");
- 
-@@ -42,8 +46,13 @@ bool JavaThread::pd_get_top_frame_for_profiling(frame* fr_addr, void* ucontext,
-   // if we were running Java code when SIGPROF came in.
-   if (isInJava) {
-     ucontext_t* uc = (ucontext_t*) ucontext;
-+#ifndef MUSL_LIBC
-     frame ret_frame((intptr_t*)uc->uc_mcontext.regs->gpr[1/*REG_SP*/],
-                      (address)uc->uc_mcontext.regs->nip);
-+#else
-+    frame ret_frame((intptr_t*)uc->uc_mcontext.gp_regs[1/*REG_SP*/],
-+                     (address)uc->uc_mcontext.gp_regs[PT_NIP]);
-+#endif
- 
-     if (ret_frame.pc() == NULL) {
-       // ucontext wasn't useful
-@@ -56,7 +65,11 @@ bool JavaThread::pd_get_top_frame_for_profiling(frame* fr_addr, void* ucontext,
-       if (m == NULL || !m->is_valid_method()) return false;
-       if (!Metaspace::contains((const void*)m)) return false;
- 
-+#ifndef MUSL_LIBC
-       uint64_t reg_bcp = uc->uc_mcontext.regs->gpr[14/*R14_bcp*/];
-+#else
-+      uint64_t reg_bcp = uc->uc_mcontext.gp_regs[14/*R14_bcp*/];
-+#endif
-       uint64_t istate_bcp = istate->bcp;
-       uint64_t code_start = (uint64_t)(m->code_base());
-       uint64_t code_end = (uint64_t)(m->code_base() + m->code_size());
--- 
-2.52.0
-
diff --git a/patches/alpine-jdk8u/0010-Update-includes-for-musl-libc.patch b/patches/alpine-jdk8u/0010-Update-includes-for-musl-libc.patch
deleted file mode 100644
index 3e028d5..0000000
--- a/patches/alpine-jdk8u/0010-Update-includes-for-musl-libc.patch
+++ /dev/null
@@ -1,317 +0,0 @@
-From 7f1dda82b35e06ba752a3996ea0d5721ba5cfd52 Mon Sep 17 00:00:00 2001
-From: Stephanie Crater <scrater@microsoft.com>
-Date: Mon, 7 Mar 2022 15:26:55 -0800
-Subject: [PATCH] Update includes for musl libc
-
----
- hotspot/src/os/linux/vm/os_linux.inline.hpp            |  7 ++++++-
- jdk/src/aix/native/java/net/aix_close.c                |  4 ++++
- jdk/src/aix/native/sun/nio/ch/AixNativeThread.c        |  5 +++++
- jdk/src/aix/native/sun/nio/ch/AixPollPort.c            |  7 ++++++-
- jdk/src/macosx/javavm/export/jvm_md.h                  |  5 +++++
- .../share/native/com/sun/java/util/jar/pack/zip.cpp    |  4 ++++
- jdk/src/share/native/com/sun/java/util/jar/pack/zip.h  |  4 ++++
- jdk/src/share/native/sun/awt/medialib/mlib_types.h     |  4 ++++
- jdk/src/solaris/javavm/export/jvm_md.h                 |  5 +++++
- jdk/src/solaris/native/java/net/bsd_close.c            |  5 +++++
- jdk/src/solaris/native/java/net/linux_close.c          |  5 +++++
- jdk/src/solaris/native/java/net/net_util_md.h          |  6 +++++-
- .../solaris/native/sun/nio/ch/DevPollArrayWrapper.c    |  7 ++++++-
- jdk/src/solaris/native/sun/nio/ch/Net.c                |  5 +++++
- jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c  |  7 ++++++-
- jdk/src/solaris/transport/socket/socket_md.c           | 10 +++++++---
- 16 files changed, 82 insertions(+), 8 deletions(-)
-
-diff --git a/hotspot/src/os/linux/vm/os_linux.inline.hpp b/hotspot/src/os/linux/vm/os_linux.inline.hpp
-index a23bd56313..80b977711e 100644
---- a/hotspot/src/os/linux/vm/os_linux.inline.hpp
-+++ b/hotspot/src/os/linux/vm/os_linux.inline.hpp
-@@ -33,9 +33,14 @@
- 
- #include <unistd.h>
- #include <sys/socket.h>
--#include <sys/poll.h>
- #include <netdb.h>
- 
-+#ifndef MUSL_LIBC
-+#include <sys/poll.h>
-+#else
-+#include <poll.h>
-+#endif
-+
- inline void* os::thread_local_storage_at(int index) {
-   return pthread_getspecific((pthread_key_t)index);
- }
-diff --git a/jdk/src/aix/native/java/net/aix_close.c b/jdk/src/aix/native/java/net/aix_close.c
-index 90d57b42f0..dfd20581ff 100644
---- a/jdk/src/aix/native/java/net/aix_close.c
-+++ b/jdk/src/aix/native/java/net/aix_close.c
-@@ -54,7 +54,11 @@
- #include <unistd.h>
- #include <errno.h>
- 
-+#ifndef MUSL_LIBC
- #include <sys/poll.h>
-+#else
-+#include <poll.h>
-+#endif
- 
- /*
-  * Stack allocated by thread when doing blocking operation
-diff --git a/jdk/src/aix/native/sun/nio/ch/AixNativeThread.c b/jdk/src/aix/native/sun/nio/ch/AixNativeThread.c
-index c0d5857962..66098cc36d 100644
---- a/jdk/src/aix/native/sun/nio/ch/AixNativeThread.c
-+++ b/jdk/src/aix/native/sun/nio/ch/AixNativeThread.c
-@@ -32,7 +32,12 @@
- #include "sun_nio_ch_NativeThread.h"
- 
- #include <pthread.h>
-+
-+#ifndef MUSL_LIBC
- #include <sys/signal.h>
-+#else
-+#include <signal.h>
-+#endif
- 
- /* Also defined in src/aix/native/java/net/aix_close.c */
- #define INTERRUPT_SIGNAL (SIGRTMAX - 1)
-diff --git a/jdk/src/aix/native/sun/nio/ch/AixPollPort.c b/jdk/src/aix/native/sun/nio/ch/AixPollPort.c
-index 70064b890e..c0466dcc9f 100644
---- a/jdk/src/aix/native/sun/nio/ch/AixPollPort.c
-+++ b/jdk/src/aix/native/sun/nio/ch/AixPollPort.c
-@@ -34,13 +34,18 @@
- #include <unistd.h>
- #include <sys/types.h>
- #include <sys/socket.h>
--#include <sys/poll.h>
- #include <sys/pollset.h>
- #include <fcntl.h>
- #include <stddef.h>
- #include <dlfcn.h>
- #include <errno.h>
- 
-+#ifndef MUSL_LIBC
-+#include <sys/poll.h>
-+#else
-+#include <poll.h>
-+#endif
-+
- /* Initially copied from src/solaris/native/sun/nio/ch/nio_util.h */
- #define RESTARTABLE(_cmd, _result) do { \
-   do { \
-diff --git a/jdk/src/macosx/javavm/export/jvm_md.h b/jdk/src/macosx/javavm/export/jvm_md.h
-index 012bb1babe..592bfb5ab9 100644
---- a/jdk/src/macosx/javavm/export/jvm_md.h
-+++ b/jdk/src/macosx/javavm/export/jvm_md.h
-@@ -60,7 +60,12 @@
- #include <sys/stat.h>
- #include <fcntl.h>
- #include <errno.h>
-+
-+#ifndef MUSL_LIBC
- #include <sys/signal.h>
-+#else
-+#include <signal.h>
-+#endif
- 
- /* O Flags */
- 
-diff --git a/jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp b/jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp
-index f58c94956c..0afbf6bb98 100644
---- a/jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp
-+++ b/jdk/src/share/native/com/sun/java/util/jar/pack/zip.cpp
-@@ -46,6 +46,10 @@
- 
- #include "zip.h"
- 
-+#ifdef MUSL_LIBC
-+#define uchar unsigned char
-+#endif
-+
- #ifdef NO_ZLIB
- 
- inline bool jar::deflate_bytes(bytes& head, bytes& tail) {
-diff --git a/jdk/src/share/native/com/sun/java/util/jar/pack/zip.h b/jdk/src/share/native/com/sun/java/util/jar/pack/zip.h
-index 14ffc9d65b..4137714f7d 100644
---- a/jdk/src/share/native/com/sun/java/util/jar/pack/zip.h
-+++ b/jdk/src/share/native/com/sun/java/util/jar/pack/zip.h
-@@ -23,9 +23,13 @@
-  * questions.
-  */
- 
-+#ifndef MUSL_LIBC
- #define ushort unsigned short
- #define uint   unsigned int
- #define uchar  unsigned char
-+#else
-+#include <sys/types.h>
-+#endif
- 
- struct unpacker;
- 
-diff --git a/jdk/src/share/native/sun/awt/medialib/mlib_types.h b/jdk/src/share/native/sun/awt/medialib/mlib_types.h
-index aba0394ffd..ad548aef64 100644
---- a/jdk/src/share/native/sun/awt/medialib/mlib_types.h
-+++ b/jdk/src/share/native/sun/awt/medialib/mlib_types.h
-@@ -27,6 +27,10 @@
- #ifndef MLIB_TYPES_H
- #define MLIB_TYPES_H
- 
-+#ifdef MUSL_LIBC
-+#include <stddef.h>                     /* for NULL */
-+#endif
-+
- #include <limits.h>
- #if defined(_MSC_VER)
- #include <float.h>                      /* for FLT_MAX and DBL_MAX */
-diff --git a/jdk/src/solaris/javavm/export/jvm_md.h b/jdk/src/solaris/javavm/export/jvm_md.h
-index 5c681914bb..a181456010 100644
---- a/jdk/src/solaris/javavm/export/jvm_md.h
-+++ b/jdk/src/solaris/javavm/export/jvm_md.h
-@@ -65,7 +65,12 @@
- #include <sys/stat.h>
- #include <fcntl.h>
- #include <errno.h>
-+
-+#ifndef MUSL_LIBC
- #include <sys/signal.h>
-+#else
-+#include <signal.h>
-+#endif
- 
- /* O Flags */
- 
-diff --git a/jdk/src/solaris/native/java/net/bsd_close.c b/jdk/src/solaris/native/java/net/bsd_close.c
-index 89a20707c4..73e1a291cf 100644
---- a/jdk/src/solaris/native/java/net/bsd_close.c
-+++ b/jdk/src/solaris/native/java/net/bsd_close.c
-@@ -38,7 +38,12 @@
- #include <sys/uio.h>
- #include <unistd.h>
- #include <errno.h>
-+
-+#ifndef MUSL_LIBC
- #include <sys/poll.h>
-+#else
-+#include <poll.h>
-+#endif
- 
- /*
-  * Stack allocated by thread when doing blocking operation
-diff --git a/jdk/src/solaris/native/java/net/linux_close.c b/jdk/src/solaris/native/java/net/linux_close.c
-index eacc2afd15..457ac8bdf9 100644
---- a/jdk/src/solaris/native/java/net/linux_close.c
-+++ b/jdk/src/solaris/native/java/net/linux_close.c
-@@ -36,7 +36,12 @@
- #include <sys/uio.h>
- #include <unistd.h>
- #include <errno.h>
-+
-+#ifndef MUSL_LIBC
- #include <sys/poll.h>
-+#else
-+#include <poll.h>
-+#endif
- 
- /*
-  * Stack allocated by thread when doing blocking operation
-diff --git a/jdk/src/solaris/native/java/net/net_util_md.h b/jdk/src/solaris/native/java/net/net_util_md.h
-index a48446de9c..d0b61a6ba1 100644
---- a/jdk/src/solaris/native/java/net/net_util_md.h
-+++ b/jdk/src/solaris/native/java/net/net_util_md.h
-@@ -33,7 +33,11 @@
- #include <unistd.h>
- 
- #ifndef USE_SELECT
--#include <sys/poll.h>
-+#ifndef MUSL_LIBC
-+  #include <sys/poll.h>
-+#else
-+  #include <poll.h>
-+#endif
- #endif
- 
- 
-diff --git a/jdk/src/solaris/native/sun/nio/ch/DevPollArrayWrapper.c b/jdk/src/solaris/native/sun/nio/ch/DevPollArrayWrapper.c
-index 6860a167bb..b581508cf4 100644
---- a/jdk/src/solaris/native/sun/nio/ch/DevPollArrayWrapper.c
-+++ b/jdk/src/solaris/native/sun/nio/ch/DevPollArrayWrapper.c
-@@ -28,10 +28,15 @@
- #include "jvm.h"
- #include "jlong.h"
- #include "sun_nio_ch_DevPollArrayWrapper.h"
--#include <sys/poll.h>
- #include <unistd.h>
- #include <sys/time.h>
- 
-+#ifndef MUSL_LIBC
-+#include <sys/poll.h>
-+#else
-+#include <poll.h>
-+#endif
-+
- #ifdef  __cplusplus
- extern "C" {
- #endif
-diff --git a/jdk/src/solaris/native/sun/nio/ch/Net.c b/jdk/src/solaris/native/sun/nio/ch/Net.c
-index fcb6197c1d..37f04646bd 100644
---- a/jdk/src/solaris/native/sun/nio/ch/Net.c
-+++ b/jdk/src/solaris/native/sun/nio/ch/Net.c
-@@ -23,7 +23,12 @@
-  * questions.
-  */
- 
-+#ifndef MUSL_LIBC
- #include <sys/poll.h>
-+#else
-+#include <poll.h>
-+#endif
-+
- #include <sys/types.h>
- #include <sys/socket.h>
- #include <string.h>
-diff --git a/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c b/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c
-index 375aaa4850..d2169095a2 100644
---- a/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c
-+++ b/jdk/src/solaris/native/sun/nio/fs/LinuxWatchService.c
-@@ -32,9 +32,14 @@
- #include <dlfcn.h>
- #include <sys/types.h>
- #include <sys/socket.h>
--#include <sys/poll.h>
- #include <sys/inotify.h>
- 
-+#ifndef MUSL_LIBC
-+#include <sys/poll.h>
-+#else
-+#include <poll.h>
-+#endif
-+
- #include "sun_nio_fs_LinuxWatchService.h"
- 
- static void throwUnixException(JNIEnv* env, int errnum) {
-diff --git a/jdk/src/solaris/transport/socket/socket_md.c b/jdk/src/solaris/transport/socket/socket_md.c
-index 33e062e087..e4f6b56ad4 100644
---- a/jdk/src/solaris/transport/socket/socket_md.c
-+++ b/jdk/src/solaris/transport/socket/socket_md.c
-@@ -34,10 +34,14 @@
- #include <string.h>
- #include <sys/time.h>
- #ifdef __solaris__
--#include <thread.h>
-+  #include <thread.h>
- #else
--#include <pthread.h>
--#include <sys/poll.h>
-+  #include <pthread.h>
-+  #ifndef MUSL_LIBC
-+    #include <sys/poll.h>
-+  #else
-+    #include <poll.h>
-+  #endif
- #endif
- 
- #include "socket_md.h"
--- 
-2.52.0
-
diff --git a/patches/alpine-jdk8u/0011-__SIGRTMAX-is-not-defined-in-musl-libc.patch b/patches/alpine-jdk8u/0011-__SIGRTMAX-is-not-defined-in-musl-libc.patch
deleted file mode 100644
index 03987cb..0000000
--- a/patches/alpine-jdk8u/0011-__SIGRTMAX-is-not-defined-in-musl-libc.patch
+++ /dev/null
@@ -1,56 +0,0 @@
-From eebeb5f6e910c116bdf7fb9b2d264ee00594507d Mon Sep 17 00:00:00 2001
-From: Stephanie Crater <scrater@microsoft.com>
-Date: Mon, 7 Mar 2022 14:43:32 -0800
-Subject: [PATCH] __SIGRTMAX is not defined in musl libc
-
----
- jdk/src/solaris/native/java/net/linux_close.c    | 5 ++++-
- jdk/src/solaris/native/sun/nio/ch/NativeThread.c | 8 ++++++--
- 2 files changed, 10 insertions(+), 3 deletions(-)
-
-diff --git a/jdk/src/solaris/native/java/net/linux_close.c b/jdk/src/solaris/native/java/net/linux_close.c
-index 457ac8bdf9..fae8a6f084 100644
---- a/jdk/src/solaris/native/java/net/linux_close.c
-+++ b/jdk/src/solaris/native/java/net/linux_close.c
-@@ -63,7 +63,7 @@ typedef struct {
- /*
-  * Signal to unblock thread
-  */
--static int sigWakeup = (__SIGRTMAX - 2);
-+static int sigWakeup;
- 
- /*
-  * fdTable holds one entry per file descriptor, up to a certain
-@@ -152,6 +152,9 @@ static void __attribute((constructor)) init() {
-     /*
-      * Setup the signal handler
-      */
-+#ifndef _AIX
-+    sigWakeup = SIGRTMAX - 2;
-+#endif
-     sa.sa_handler = sig_wakeup;
-     sa.sa_flags   = 0;
-     sigemptyset(&sa.sa_mask);
-diff --git a/jdk/src/solaris/native/sun/nio/ch/NativeThread.c b/jdk/src/solaris/native/sun/nio/ch/NativeThread.c
-index 5e2a78b7af..b512b10aed 100644
---- a/jdk/src/solaris/native/sun/nio/ch/NativeThread.c
-+++ b/jdk/src/solaris/native/sun/nio/ch/NativeThread.c
-@@ -34,9 +34,13 @@
- 
- #ifdef __linux__
-   #include <pthread.h>
--  #include <sys/signal.h>
-+  #ifndef MUSL_LIBC
-+    #include <sys/signal.h>
-+  #else
-+    #include <signal.h>
-+  #endif
-   /* Also defined in net/linux_close.c */
--  #define INTERRUPT_SIGNAL (__SIGRTMAX - 2)
-+  #define INTERRUPT_SIGNAL (SIGRTMAX - 2)
- #elif __solaris__
-   #include <thread.h>
-   #include <signal.h>
--- 
-2.52.0
-
diff --git a/patches/alpine-jdk8u/0012-Remove-unused-print_stack-void-method.patch b/patches/alpine-jdk8u/0012-Remove-unused-print_stack-void-method.patch
deleted file mode 100644
index 9550e19..0000000
--- a/patches/alpine-jdk8u/0012-Remove-unused-print_stack-void-method.patch
+++ /dev/null
@@ -1,53 +0,0 @@
-From f5842232ae41cec0422ebc09b8bf76a690a8111f Mon Sep 17 00:00:00 2001
-From: Stephanie Crater <scrater@microsoft.com>
-Date: Mon, 7 Mar 2022 14:23:34 -0800
-Subject: [PATCH] Remove unused print_stack(void) method
-
----
- jdk/src/solaris/native/sun/xawt/XToolkit.c | 23 ----------------------
- 1 file changed, 23 deletions(-)
-
-diff --git a/jdk/src/solaris/native/sun/xawt/XToolkit.c b/jdk/src/solaris/native/sun/xawt/XToolkit.c
-index 24557cba41..1123389585 100644
---- a/jdk/src/solaris/native/sun/xawt/XToolkit.c
-+++ b/jdk/src/solaris/native/sun/xawt/XToolkit.c
-@@ -27,9 +27,6 @@
- #include <X11/Xutil.h>
- #include <X11/Xos.h>
- #include <X11/Xatom.h>
--#ifdef __linux__
--#include <execinfo.h>
--#endif
- 
- #include <jvm.h>
- #include <jni.h>
-@@ -796,26 +793,6 @@ JNIEXPORT jstring JNICALL Java_sun_awt_X11_XToolkit_getEnv
-     return ret;
- }
- 
--#ifdef __linux__
--void print_stack(void)
--{
--  void *array[10];
--  size_t size;
--  char **strings;
--  size_t i;
--
--  size = backtrace (array, 10);
--  strings = backtrace_symbols (array, size);
--
--  fprintf (stderr, "Obtained %zd stack frames.\n", size);
--
--  for (i = 0; i < size; i++)
--     fprintf (stderr, "%s\n", strings[i]);
--
--  free (strings);
--}
--#endif
--
- Window get_xawt_root_shell(JNIEnv *env) {
-   static jclass classXRootWindow = NULL;
-   static jmethodID methodGetXRootWindow = NULL;
--- 
-2.52.0
-
diff --git a/patches/alpine-jdk8u/0013-Fix-separator-error-in-sa.make.patch b/patches/alpine-jdk8u/0013-Fix-separator-error-in-sa.make.patch
deleted file mode 100644
index e5811bc..0000000
--- a/patches/alpine-jdk8u/0013-Fix-separator-error-in-sa.make.patch
+++ /dev/null
@@ -1,25 +0,0 @@
-From db6123c6fb92df7ac2943da6b617eedbd47a90b6 Mon Sep 17 00:00:00 2001
-From: Stephanie Crater <scrater@microsoft.com>
-Date: Tue, 8 Mar 2022 11:49:37 -0800
-Subject: [PATCH] Fix separator error in sa.make
-
----
- hotspot/make/linux/makefiles/sa.make | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/hotspot/make/linux/makefiles/sa.make b/hotspot/make/linux/makefiles/sa.make
-index 5c2f661ee1..8d2f31e7cb 100644
---- a/hotspot/make/linux/makefiles/sa.make
-+++ b/hotspot/make/linux/makefiles/sa.make
-@@ -62,7 +62,7 @@ SA_PROPERTIES = $(SA_CLASSDIR)/sa.properties
- # check for thread_db.h too (musl does not have it).
- 
- all: 
--if [ -d $(AGENT_DIR) -a -f /usr/include/thread_db.h \
-+	if [ -d $(AGENT_DIR) -a -f /usr/include/thread_db.h \
-              -a "$(SRCARCH)" != "ia64" \
-              -a "$(SRCARCH)" != "zero" ] ; then \
- 	   $(MAKE) -f sa.make $(GENERATED)/sa-jdi.jar; \
--- 
-2.52.0
-
diff --git a/patches/alpine-jdk8u/0014-Fix-includes-for-musl-on-linux-aarch64.patch b/patches/alpine-jdk8u/0014-Fix-includes-for-musl-on-linux-aarch64.patch
deleted file mode 100644
index 4823b27..0000000
--- a/patches/alpine-jdk8u/0014-Fix-includes-for-musl-on-linux-aarch64.patch
+++ /dev/null
@@ -1,25 +0,0 @@
-From 2df931ef8b75f00454be99001e6abb5df4f518e8 Mon Sep 17 00:00:00 2001
-From: Stephanie Crater <scrater@microsoft.com>
-Date: Mon, 23 May 2022 10:23:07 -0700
-Subject: [PATCH] Fix includes for musl on linux aarch64
-
----
- hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp b/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
-index cf476a0b27..e2cd5e60e7 100644
---- a/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
-+++ b/hotspot/src/os_cpu/linux_aarch64/vm/os_linux_aarch64.cpp
-@@ -73,7 +73,7 @@
- # include <poll.h>
- # include <ucontext.h>
- 
--#ifdef MUSL_LIBC
-+#ifndef MUSL_LIBC
- #include <fpu_control.h>
- #else
- #include <linux/types.h>  /* provides __u64 */
--- 
-2.52.0
-
diff --git a/patches/alpine-jdk8u/0015-Regenerate-generated-configure.sh.patch b/patches/alpine-jdk8u/0015-Regenerate-generated-configure.sh.patch
deleted file mode 100644
index 19930b7..0000000
--- a/patches/alpine-jdk8u/0015-Regenerate-generated-configure.sh.patch
+++ /dev/null
@@ -1,270 +0,0 @@
-From bb6c1b5f95c41f5219ce8353c6110f65b54d5658 Mon Sep 17 00:00:00 2001
-From: Stephanie Crater <scrater@microsoft.com>
-Date: Fri, 13 Jan 2023 15:05:16 -0800
-Subject: [PATCH] Regenerate generated-configure.sh
-
----
- common/autoconf/generated-configure.sh | 104 ++++++++++++++++++++-----
- 1 file changed, 83 insertions(+), 21 deletions(-)
-
-diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
-index c926f7d75e..4b1c9b82b1 100644
---- a/common/autoconf/generated-configure.sh
-+++ b/common/autoconf/generated-configure.sh
-@@ -919,6 +919,7 @@ OPENJDK_TARGET_CPU_LEGACY
- REQUIRED_OS_VERSION
- REQUIRED_OS_NAME
- COMPILE_TYPE
-+OPENJDK_TARGET_LIBC
- OPENJDK_TARGET_CPU_ENDIAN
- OPENJDK_TARGET_CPU_BITS
- OPENJDK_TARGET_CPU_ARCH
-@@ -926,6 +927,7 @@ OPENJDK_TARGET_CPU
- OPENJDK_TARGET_OS_ENV
- OPENJDK_TARGET_OS_API
- OPENJDK_TARGET_OS
-+OPENJDK_BUILD_LIBC
- OPENJDK_BUILD_CPU_ENDIAN
- OPENJDK_BUILD_CPU_BITS
- OPENJDK_BUILD_CPU_ARCH
-@@ -1015,7 +1017,6 @@ infodir
- docdir
- oldincludedir
- includedir
--runstatedir
- localstatedir
- sharedstatedir
- sysconfdir
-@@ -1260,7 +1261,6 @@ datadir='${datarootdir}'
- sysconfdir='${prefix}/etc'
- sharedstatedir='${prefix}/com'
- localstatedir='${prefix}/var'
--runstatedir='${localstatedir}/run'
- includedir='${prefix}/include'
- oldincludedir='/usr/include'
- docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
-@@ -1513,15 +1513,6 @@ do
-   | -silent | --silent | --silen | --sile | --sil)
-     silent=yes ;;
- 
--  -runstatedir | --runstatedir | --runstatedi | --runstated \
--  | --runstate | --runstat | --runsta | --runst | --runs \
--  | --run | --ru | --r)
--    ac_prev=runstatedir ;;
--  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
--  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
--  | --run=* | --ru=* | --r=*)
--    runstatedir=$ac_optarg ;;
--
-   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
-     ac_prev=sbindir ;;
-   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
-@@ -1659,7 +1650,7 @@ fi
- for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
- 		datadir sysconfdir sharedstatedir localstatedir includedir \
- 		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
--		libdir localedir mandir runstatedir
-+		libdir localedir mandir
- do
-   eval ac_val=\$$ac_var
-   # Remove trailing slashes.
-@@ -1812,7 +1803,6 @@ Fine tuning of the installation directories:
-   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
-   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
-   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
--  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
-   --libdir=DIR            object code libraries [EPREFIX/lib]
-   --includedir=DIR        C header files [PREFIX/include]
-   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
-@@ -1919,7 +1909,7 @@ Optional Packages:
-                           Add a custom string to the version string if build
-                           number isn't set.[username_builddateb00]
-   --with-build-number     Set build number value for build [b00]
--  --with-company-name     Set company name
-+  --with-company-name     Set company name.
-   --with-vendor-name      Set vendor name. Among others, used to set the
-                           'java.vendor' and 'java.vm.vendor' system
-                           properties. [not specified]
-@@ -4086,6 +4076,11 @@ fi
- # VAR_OS and VAR_OS_API.
- 
- 
-+# Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
-+# Converts autoconf style OS name to OpenJDK style, into
-+# VAR_LIBC.
-+
-+
- # Expects $host_os $host_cpu $build_os and $build_cpu
- # and $with_target_bits to have been setup!
- #
-@@ -4419,7 +4414,7 @@ VS_TOOLSET_SUPPORTED_2019=false
- #CUSTOM_AUTOCONF_INCLUDE
- 
- # Do not change or remove the following line, it is needed for consistency checks:
--DATE_WHEN_GENERATED=1652838310
-+DATE_WHEN_GENERATED=1673650816
- 
- ###############################################################################
- #
-@@ -13611,7 +13606,7 @@ test -n "$target_alias" &&
- 
- 
- 
--  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
-+  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
- 
-   case "$build_os" in
-     *linux*)
-@@ -13728,6 +13723,19 @@ test -n "$target_alias" &&
-       ;;
-   esac
- 
-+
-+  case "$build_os" in
-+    *linux*-musl)
-+      VAR_LIBC=musl
-+      ;;
-+    *linux*-gnu)
-+      VAR_LIBC=gnu
-+      ;;
-+    *)
-+      VAR_LIBC=default
-+      ;;
-+  esac
-+
-   # ..and setup our own variables. (Do this explicitely to facilitate searching)
-   OPENJDK_BUILD_OS="$VAR_OS"
-   OPENJDK_BUILD_OS_API="$VAR_OS_API"
-@@ -13736,6 +13744,8 @@ test -n "$target_alias" &&
-   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
-   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
-   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
-+  OPENJDK_BUILD_LIBC="$VAR_LIBC"
-+
- 
- 
- 
-@@ -13749,7 +13759,14 @@ $as_echo_n "checking openjdk-build os-cpu... " >&6; }
-   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
- $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
- 
--  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
-+  if test "x$OPENJDK_BUILD_OS" = "xlinux"; then
-+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build C library" >&5
-+$as_echo_n "checking openjdk-build C library... " >&6; }
-+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_LIBC" >&5
-+$as_echo "$OPENJDK_BUILD_LIBC" >&6; }
-+  fi
-+
-+  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
- 
-   case "$host_os" in
-     *linux*)
-@@ -13866,6 +13883,19 @@ $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
-       ;;
-   esac
- 
-+
-+  case "$host_os" in
-+    *linux*-musl)
-+      VAR_LIBC=musl
-+      ;;
-+    *linux*-gnu)
-+      VAR_LIBC=gnu
-+      ;;
-+    *)
-+      VAR_LIBC=default
-+      ;;
-+  esac
-+
-   # ... and setup our own variables. (Do this explicitely to facilitate searching)
-   OPENJDK_TARGET_OS="$VAR_OS"
-   OPENJDK_TARGET_OS_API="$VAR_OS_API"
-@@ -13874,6 +13904,8 @@ $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
-   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
-   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
-   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
-+  OPENJDK_TARGET_LIBC="$VAR_LIBC"
-+
- 
- 
- 
-@@ -13887,6 +13919,13 @@ $as_echo_n "checking openjdk-target os-cpu... " >&6; }
-   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
- $as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
- 
-+  if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
-+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target C library" >&5
-+$as_echo_n "checking openjdk-target C library... " >&6; }
-+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_LIBC" >&5
-+$as_echo "$OPENJDK_TARGET_LIBC" >&6; }
-+  fi
-+
- 
- 
- # Check whether --with-target-bits was given.
-@@ -14648,6 +14687,9 @@ $as_echo "$with_jvm_variants" >&6; }
- 
- 
-   INCLUDE_SA=true
-+  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
-+    INCLUDE_SA=false
-+  fi
-   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
-     INCLUDE_SA=false
-   fi
-@@ -20140,6 +20182,19 @@ fi
- 
-   # Now set the JDK version, milestone, build number etc.
- 
-+
-+
-+
-+
-+
-+
-+
-+
-+
-+
-+
-+
-+
-   # The company name, if any
- 
- # Check whether --with-company-name was given.
-@@ -20155,6 +20210,7 @@ fi
-     COMPANY_NAME="$with_company_name"
-   fi
- 
-+
-   # The vendor name, if any
- 
- # Check whether --with-vendor-name was given.
-@@ -42252,13 +42308,19 @@ if test "${with_extra_asflags+set}" = set; then :
- fi
- 
- 
--  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags"
--  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags"
-+  # Define MUSL_LIBC
-+  DEFINE_LIBC=""
-+  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
-+    DEFINE_LIBC="-DMUSL_LIBC"
-+  fi
-+
-+  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags ${DEFINE_LIBC}"
-+  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags ${DEFINE_LIBC}"
-   LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
- 
-   # Hotspot needs these set in their legacy form
--  LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $with_extra_cflags"
--  LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $with_extra_cxxflags"
-+  LEGACY_EXTRA_CFLAGS="$LEGACY_EXTRA_CFLAGS $with_extra_cflags $DEFINE_LIBC"
-+  LEGACY_EXTRA_CXXFLAGS="$LEGACY_EXTRA_CXXFLAGS $with_extra_cxxflags $DEFINE_LIBC"
-   LEGACY_EXTRA_LDFLAGS="$LEGACY_EXTRA_LDFLAGS $with_extra_ldflags"
-   LEGACY_EXTRA_ASFLAGS="$with_extra_asflags"
- 
--- 
-2.52.0
-
diff --git a/patches/alpine-jdk8u/0016-Regen-generated-configure.sh-as-contains-conflict-msgs.patch b/patches/alpine-jdk8u/0016-Regen-generated-configure.sh-as-contains-conflict-msgs.patch
deleted file mode 100644
index 5f5e415..0000000
--- a/patches/alpine-jdk8u/0016-Regen-generated-configure.sh-as-contains-conflict-msgs.patch
+++ /dev/null
@@ -1,34 +0,0 @@
-From e06ef7a848eeadd1ee1969997e304524356b1805 Mon Sep 17 00:00:00 2001
-From: Andrew Leonard <anleonar@redhat.com>
-Date: Thu, 23 Feb 2023 11:17:22 +0000
-Subject: [PATCH] Regen generated-configure.sh as contains conflict msgs
-
-Signed-off-by: Andrew Leonard <anleonar@redhat.com>
----
- common/autoconf/generated-configure.sh | 10 +---------
- 1 file changed, 1 insertion(+), 9 deletions(-)
-
-diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
-index a08bec3219..00a210900a 100644
---- a/common/autoconf/generated-configure.sh
-+++ b/common/autoconf/generated-configure.sh
-@@ -4994,15 +4994,7 @@ VS_TOOLSET_SUPPORTED_2019=false
- #CUSTOM_AUTOCONF_INCLUDE
- 
- # Do not change or remove the following line, it is needed for consistency checks:
--<<<<<<< HEAD
--<<<<<<< HEAD
--DATE_WHEN_GENERATED=1673650816
--=======
--DATE_WHEN_GENERATED=1670219878
-->>>>>>> origin/master
--=======
--DATE_WHEN_GENERATED=1676455289
-->>>>>>> origin/release
-+DATE_WHEN_GENERATED=1677150961
- 
- ###############################################################################
- #
--- 
-2.52.0
-
diff --git a/patches/alpine-jdk8u/0017-Regen-generated-configure.sh-as-contains-conflict-msgs.patch b/patches/alpine-jdk8u/0017-Regen-generated-configure.sh-as-contains-conflict-msgs.patch
deleted file mode 100644
index f1e8d29..0000000
--- a/patches/alpine-jdk8u/0017-Regen-generated-configure.sh-as-contains-conflict-msgs.patch
+++ /dev/null
@@ -1,26 +0,0 @@
-From 748e72a2784e6062dd4fe2cc624ddf0e4445fe73 Mon Sep 17 00:00:00 2001
-From: Andrew Leonard <anleonar@redhat.com>
-Date: Thu, 23 Feb 2023 11:18:52 +0000
-Subject: [PATCH] Regen generated-configure.sh as contains conflict msgs
-
-Signed-off-by: Andrew Leonard <anleonar@redhat.com>
----
- common/autoconf/generated-configure.sh | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
-index e12e97757f..358b389ad0 100644
---- a/common/autoconf/generated-configure.sh
-+++ b/common/autoconf/generated-configure.sh
-@@ -4994,7 +4994,7 @@ VS_TOOLSET_SUPPORTED_2019=false
- #CUSTOM_AUTOCONF_INCLUDE
- 
- # Do not change or remove the following line, it is needed for consistency checks:
--DATE_WHEN_GENERATED=1676455289
-+DATE_WHEN_GENERATED=1677151107
- 
- ###############################################################################
- #
--- 
-2.52.0
-
diff --git a/patches/alpine-jdk8u/0018-Fix-error-in-MUSL-merge-conflict-resolution.patch b/patches/alpine-jdk8u/0018-Fix-error-in-MUSL-merge-conflict-resolution.patch
deleted file mode 100644
index bbdf5c7..0000000
--- a/patches/alpine-jdk8u/0018-Fix-error-in-MUSL-merge-conflict-resolution.patch
+++ /dev/null
@@ -1,61 +0,0 @@
-From 8d8cad934909e4ce1dda33eedb476cc62511f143 Mon Sep 17 00:00:00 2001
-From: Andrew Leonard <anleonar@redhat.com>
-Date: Wed, 4 Sep 2024 14:46:37 +0100
-Subject: [PATCH] Fix error in MUSL merge conflict resolution
-
-Signed-off-by: Andrew Leonard <anleonar@redhat.com>
----
- common/autoconf/flags.m4               |  8 ++++----
- common/autoconf/generated-configure.sh | 10 +++++-----
- 2 files changed, 9 insertions(+), 9 deletions(-)
-
-diff --git a/common/autoconf/flags.m4 b/common/autoconf/flags.m4
-index 46245bafbd..2cef5aa3c5 100644
---- a/common/autoconf/flags.m4
-+++ b/common/autoconf/flags.m4
-@@ -491,10 +491,10 @@ AC_DEFUN_ONCE([FLAGS_SETUP_COMPILER_FLAGS_FOR_JDK],
-   LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
- 
-   # Hotspot needs these set in their legacy form
--  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags"
--  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags"
--  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags"
--  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags"
-+  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
-+  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
-+  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
-+  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
-   LEGACY_HOST_LDFLAGS="$LEGACY_HOST_LDFLAGS $with_extra_ldflags"
-   LEGACY_TARGET_LDFLAGS="$LEGACY_TARGET_LDFLAGS $with_extra_ldflags"
-   LEGACY_HOST_ASFLAGS="$with_extra_asflags"
-diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
-index e89a61a6c5..2eb58c981a 100644
---- a/common/autoconf/generated-configure.sh
-+++ b/common/autoconf/generated-configure.sh
-@@ -5016,7 +5016,7 @@ VS_TOOLSET_SUPPORTED_2022=true
- #CUSTOM_AUTOCONF_INCLUDE
- 
- # Do not change or remove the following line, it is needed for consistency checks:
--DATE_WHEN_GENERATED=1725268775
-+DATE_WHEN_GENERATED=1725457575
- 
- ###############################################################################
- #
-@@ -44957,10 +44957,10 @@ fi
-   LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
- 
-   # Hotspot needs these set in their legacy form
--  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags"
--  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags"
--  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags"
--  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags"
-+  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
-+  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
-+  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
-+  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
-   LEGACY_HOST_LDFLAGS="$LEGACY_HOST_LDFLAGS $with_extra_ldflags"
-   LEGACY_TARGET_LDFLAGS="$LEGACY_TARGET_LDFLAGS $with_extra_ldflags"
-   LEGACY_HOST_ASFLAGS="$with_extra_asflags"
--- 
-2.52.0
-
diff --git a/skaraMirror.sh b/skaraMirror.sh
index ebf61a1..b648c31 100755
--- a/skaraMirror.sh
+++ b/skaraMirror.sh
@@ -32,6 +32,48 @@ function checkArgs() {
   fi
 }
 
+# For jdk8u-based repos, common/autoconf/generated-configure.sh is a build-generated file
+# that frequently conflicts during merges/rebases/patches because it is regenerated from
+# common/autoconf/*.m4 sources. This function checks if it is the ONLY conflict and if so,
+# regenerates it via autogen.sh and stages the result.
+# Must be called from within the repo working directory.
+# Returns 0 if the conflict was resolved, 1 if there are other conflicts (caller must fail).
+function resolveGeneratedConfigureConflict() {
+  local GENERATED_CONFIGURE="common/autoconf/generated-configure.sh"
+  local AUTOGEN="common/autoconf/autogen.sh"
+
+  # Only applies to jdk8u-based repos that have the autogen script
+  if [[ "${VERSION}" != "8" ]]; then
+    return 1
+  fi
+
+  # Get list of conflicted files
+  local conflicts
+  conflicts=$(git diff --name-only --diff-filter=U)
+
+  if [[ -z "$conflicts" ]]; then
+    return 1
+  fi
+
+  # Check if generated-configure.sh is the only conflict
+  if [[ "$conflicts" != "$GENERATED_CONFIGURE" ]]; then
+    echo "ERROR: Conflicts exist in files other than $GENERATED_CONFIGURE:"
+    echo "$conflicts"
+    return 1
+  fi
+
+  echo "Resolving $GENERATED_CONFIGURE conflict by regenerating via autogen.sh"
+  if [ ! -f "$AUTOGEN" ]; then
+    echo "ERROR: $AUTOGEN not found — cannot regenerate $GENERATED_CONFIGURE"
+    return 1
+  fi
+
+  bash "$AUTOGEN" || return 1
+  git add "$GENERATED_CONFIGURE" || return 1
+  echo "Successfully regenerated and staged $GENERATED_CONFIGURE"
+  return 0
+}
+
 function cloneGitHubRepo() {
   cd "$WORKSPACE" || exit 1
   # If we don't have a $GITHUB_REPO locally then clone it from adoptium/$GITHUB_REPO.git
@@ -76,7 +118,14 @@ function addSkaralUpstream() {
 function performMergeFromSkaraIntoGit() {
   git fetch skara --tags
 
-  git rebase "skara/$BRANCH" "$BRANCH"
+  if ! git rebase "skara/$BRANCH" "$BRANCH" ; then
+    if resolveGeneratedConfigureConflict ; then
+      git rebase --continue || exit 1
+    else
+      git rebase --abort
+      exit 1
+    fi
+  fi
 
   git push -u origin "$BRANCH" || exit 1
   git push origin "$BRANCH" --tags || exit 1
@@ -122,7 +171,18 @@ function performMergeIntoReleaseFromMaster() {
         echo "Skipping top-level $patchName (overridden by patches/$GITHUB_REPO/$patchName)"
       else
         echo "Applying top-level patch: $patchName"
-        git am --ignore-whitespace -3 "$patchFile" || exit 1
+        if [[ ! -s "$patchFile" ]]; then
+          echo "Skipping empty patch: $patchName"
+          continue
+        fi
+        if ! git am --ignore-whitespace -3 "$patchFile" ; then
+          if resolveGeneratedConfigureConflict ; then
+            git am --continue || exit 1
+          else
+            git am --abort
+            exit 1
+          fi
+        fi
       fi
     done
 
@@ -134,7 +194,18 @@ function performMergeIntoReleaseFromMaster() {
         [ -f "$patchFile" ] || continue
         patchName=$(basename "$patchFile")
         echo "Applying repo-specific patch: $patchName"
-        git am --ignore-whitespace -3 "$patchFile" || exit 1
+        if [[ ! -s "$patchFile" ]]; then
+          echo "Skipping empty patch: $patchName"
+          continue
+        fi
+        if ! git am --ignore-whitespace -3 "$patchFile" ; then
+          if resolveGeneratedConfigureConflict ; then
+            git am --continue || exit 1
+          else
+            git am --abort
+            exit 1
+          fi
+        fi
       done
     fi
   else
@@ -185,7 +256,14 @@ function performMergeIntoReleaseFromMaster() {
       fi
       if [[ "$mergeTag" == true ]]; then
         echo "Merging build tag $tag into $RELEASE_BRANCH branch"
-        git merge -m"Merging $tag into $RELEASE_BRANCH" $tag || exit 1
+        if ! git merge -m"Merging $tag into $RELEASE_BRANCH" $tag ; then
+          if resolveGeneratedConfigureConflict ; then
+            git commit --no-edit || exit 1
+          else
+            git merge --abort
+            exit 1
+          fi
+        fi
         git tag -a "${tag}_adopt" -m "Merged $tag into $RELEASE_BRANCH" || exit 1
         newAdoptTags="${newAdoptTags} ${tag}_adopt"
       fi
@@ -281,10 +359,24 @@ function performMergeIntoDevFromMaster() {
 
   # Merge master "HEAD"
   echo "Merging origin/$BRANCH HEAD into $DEV_BRANCH branch"
-  git merge -m"Merging origin/$BRANCH HEAD into $DEV_BRANCH" origin/"$BRANCH" || exit 1
+  if ! git merge -m"Merging origin/$BRANCH HEAD into $DEV_BRANCH" origin/"$BRANCH" ; then
+    if resolveGeneratedConfigureConflict ; then
+      git commit --no-edit || exit 1
+    else
+      git merge --abort
+      exit 1
+    fi
+  fi
 
   # Merge latest patches from "release" branch
-  git merge -m"Merging latest patches from $RELEASE_BRANCH branch" "origin/$RELEASE_BRANCH" || exit 1
+  if ! git merge -m"Merging latest patches from $RELEASE_BRANCH branch" "origin/$RELEASE_BRANCH" ; then
+    if resolveGeneratedConfigureConflict ; then
+      git commit --no-edit || exit 1
+    else
+      git merge --abort
+      exit 1
+    fi
+  fi
 
   if git rev-parse -q --verify "origin/$DEV_BRANCH" ; then
     git --no-pager log --oneline "origin/$DEV_BRANCH..$DEV_BRANCH"

From 6372489418b8fff261d6ffef0f99c2192fbc89bf Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Wed, 26 Aug 2026 13:54:48 +0100
Subject: [PATCH 16/27] chore(mirror_cspu): add actions branch ignore patch for
 jdk21u

Co-authored-by: Bob <bob@ibm.com>
---
 patches/jdk21u/actions-ignore-branches.patch | 24 ++++++++++++++++++++
 1 file changed, 24 insertions(+)
 create mode 100644 patches/jdk21u/actions-ignore-branches.patch

diff --git a/patches/jdk21u/actions-ignore-branches.patch b/patches/jdk21u/actions-ignore-branches.patch
new file mode 100644
index 0000000..7025537
--- /dev/null
+++ b/patches/jdk21u/actions-ignore-branches.patch
@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Adoptium <adoptium-mirrors@eclipse.org>
+Date: Mon, 17 Sep 2001 00:00:00 +0000
+Subject: [PATCH] skip github actions builds to save executors
+
+---
+ .github/workflows/main.yml | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
+index 5097d3e03488e90d582f8dfd2b7c147a4c342074..416878cc4c9 100644
+--- a/.github/workflows/main.yml
++++ b/.github/workflows/main.yml
+@@ -29,6 +29,8 @@ on:
+   push:
+     branches-ignore:
+       - master
++      - dev*
++      - release*
+       - pr/*
+   workflow_dispatch:
+     inputs:
+-- 
+2.39.0

From 23af0a6b62dc82df92d8e609a6b1b0f98ccdebe6 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Wed, 26 Aug 2026 15:43:28 +0100
Subject: [PATCH 17/27] fix(mirror_cspu): tag new release branch base with
 _adopt after patching

Co-authored-by: Bob <bob@ibm.com>
---
 skaraMirror.sh | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/skaraMirror.sh b/skaraMirror.sh
index b648c31..4ef8cbe 100755
--- a/skaraMirror.sh
+++ b/skaraMirror.sh
@@ -146,10 +146,13 @@ function performMergeIntoReleaseFromMaster() {
   buildTags=$(git tag --merged origin/"$BRANCH" $TAG_SEARCH || exit 1)
   sortedBuildTags=$(echo "$buildTags" | eval "$jdk_sort_tags_cmd" || exit 1)
 
+  NEW_RELEASE_BRANCH_TAG=""
   if ! git checkout -f "$RELEASE_BRANCH" ; then
     if ! git rev-parse -q --verify "origin/$RELEASE_BRANCH" ; then
       currentBuildTag=$(echo "$buildTags" | eval "$jdk_sort_tags_cmd" | tail -1 || exit 1)
       git checkout -b "$RELEASE_BRANCH" $currentBuildTag || exit 1
+      # Remember the tag this new branch was created from so we can _adopt tag it after patching
+      NEW_RELEASE_BRANCH_TAG="$currentBuildTag"
     else
       git checkout -b "$RELEASE_BRANCH" "origin/$RELEASE_BRANCH" || exit 1
     fi
@@ -208,6 +211,18 @@ function performMergeIntoReleaseFromMaster() {
         fi
       done
     fi
+
+    # If this is a brand new release branch, tag the base build tag with _adopt now that
+    # patches have been applied — the merge loop below will find no new tags to process
+    if [[ -n "$NEW_RELEASE_BRANCH_TAG" ]]; then
+      local adoptTag="${NEW_RELEASE_BRANCH_TAG}_adopt"
+      if [ "$(git tag -l "$adoptTag")" == "" ]; then
+        echo "Tagging new $RELEASE_BRANCH base tag ${adoptTag}"
+        git tag -a "$adoptTag" -m "Merged ${NEW_RELEASE_BRANCH_TAG} into $RELEASE_BRANCH" || exit 1
+      else
+        echo "Adopt tag ${adoptTag} already exists, skipping"
+      fi
+    fi
   else
     echo "README.JAVASE already exists — patches already applied, skipping"
   fi

From fcf67251151d9d833e1552a6eca1e3d0e3eb0ca4 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Thu, 27 Aug 2026 15:05:34 +0100
Subject: [PATCH 18/27] chore(mirror_cspu): add aarch32 patches and fix repo
 name mapping for aarch32-port-jdk8u

Co-authored-by: Bob <bob@ibm.com>
---
 .../0001-Set-vendor-information.patch         |  32 ++++
 .../actions-ignore-branches.patch             |  24 +++
 patches/aarch32-port-jdk8u/company_name.patch |  91 ++++++++++
 .../actions-ignore-branches.patch             |  24 +++
 .../jdk8u/0001-Set-vendor-information.patch   |  17 +-
 patches/jdk8u/actions-ignore-branches.patch   |  24 +++
 patches/jdk8u/company_name.patch              | 155 ++----------------
 skaraMirror.sh                                |   8 +-
 8 files changed, 227 insertions(+), 148 deletions(-)
 create mode 100644 patches/aarch32-port-jdk8u/0001-Set-vendor-information.patch
 create mode 100644 patches/aarch32-port-jdk8u/company_name.patch

diff --git a/patches/aarch32-port-jdk8u/0001-Set-vendor-information.patch b/patches/aarch32-port-jdk8u/0001-Set-vendor-information.patch
new file mode 100644
index 0000000..0d2f8eb
--- /dev/null
+++ b/patches/aarch32-port-jdk8u/0001-Set-vendor-information.patch
@@ -0,0 +1,32 @@
+From a170d74d4b72563fc70f227a6c7d3e64c4146631 Mon Sep 17 00:00:00 2001
+From: John Oliver <johno@insightfullogic.com>
+Date: Tue, 6 Nov 2018 10:47:15 +0000
+Subject: [PATCH] Set vendor information
+
+---
+ jdk/src/share/native/java/lang/System.c | 6 +++---
+ 1 file changed, 3 insertions(+), 3 deletions(-)
+
+diff --git a/jdk/src/share/native/java/lang/System.c b/jdk/src/share/native/java/lang/System.c
+index 04ef657465..b06a38f87e 100644
+--- a/jdk/src/share/native/java/lang/System.c
++++ b/jdk/src/share/native/java/lang/System.c
+@@ -110,13 +110,13 @@ Java_java_lang_System_identityHashCode(JNIEnv *env, jobject this, jobject x)
+ 
+ /* Third party may overwrite these values. */
+ #ifndef VENDOR
+-#define VENDOR "Oracle Corporation"
++#define VENDOR "Eclipse Foundation"
+ #endif
+ #ifndef VENDOR_URL
+-#define VENDOR_URL "http://java.oracle.com/"
++#define VENDOR_URL "https://adoptium.net/"
+ #endif
+ #ifndef VENDOR_URL_BUG
+-#define VENDOR_URL_BUG "http://bugreport.sun.com/bugreport/"
++#define VENDOR_URL_BUG "https://github.com/adoptium/adoptium-support/issues"
+ #endif
+ 
+ #define JAVA_MAX_SUPPORTED_VERSION 52
+-- 
+2.7.4
diff --git a/patches/aarch32-port-jdk8u/actions-ignore-branches.patch b/patches/aarch32-port-jdk8u/actions-ignore-branches.patch
index e69de29..d110717 100644
--- a/patches/aarch32-port-jdk8u/actions-ignore-branches.patch
+++ b/patches/aarch32-port-jdk8u/actions-ignore-branches.patch
@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Adoptium <adoptium-mirrors@eclipse.org>
+Date: Mon, 17 Sep 2001 00:00:00 +0000
+Subject: [PATCH] skip github actions builds to save executors
+
+---
+ .github/workflows/submit.yml | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/.github/workflows/submit.yml b/.github/workflows/submit.yml
+index 72e619aa83..887a20c844 100644
+--- a/.github/workflows/submit.yml
++++ b/.github/workflows/submit.yml
+@@ -4,6 +4,8 @@ on:
+   push:
+     branches-ignore:
+       - master
++      - dev*
++      - release*
+       - pr/*
+   workflow_dispatch:
+     inputs:
+-- 
+2.39.0
diff --git a/patches/aarch32-port-jdk8u/company_name.patch b/patches/aarch32-port-jdk8u/company_name.patch
new file mode 100644
index 0000000..2095e5d
--- /dev/null
+++ b/patches/aarch32-port-jdk8u/company_name.patch
@@ -0,0 +1,91 @@
+From fe098d6310075681475ffece69faf1e8e715b5e9 Mon Sep 17 00:00:00 2001
+From: John Oliver <johno@insightfullogic.com>
+Date: Thu, 30 Aug 2018 14:22:52 +0100
+Subject: [PATCH] Allow setting company name
+
+---
+ common/autoconf/jdk-options.m4                       | 11 +++++++++++
+ jdk/make/gensrc/GensrcMisc.gmk                       |  6 ++++++
+ jdk/src/share/classes/sun/misc/Version.java.template |  7 +++++--
+ 3 files changed, 22 insertions(+), 2 deletions(-)
+
+diff --git a/common/autoconf/jdk-options.m4 b/common/autoconf/jdk-options.m4
+index 18ba585209..ae9d5308f4 100644
+--- a/common/autoconf/jdk-options.m4
++++ b/common/autoconf/jdk-options.m4
+@@ -539,6 +539,17 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_JDK_VERSION_NUMBERS],
+   AC_SUBST(MACOSX_BUNDLE_NAME_BASE)
+   AC_SUBST(MACOSX_BUNDLE_ID_BASE)
+ 
++  # The company name, if any
++  AC_ARG_WITH(company-name, [AS_HELP_STRING([--with-company-name],
++      [Set company name.])])
++  if test "x$with_company_name" = xyes; then
++    AC_MSG_ERROR([--with-company-name must have a value])
++  elif [ ! [[ $with_company_name =~ ^[[:print:]]*$ ]] ]; then
++    AC_MSG_ERROR([--with-company-name contains non-printing characters: $with_company_name])
++  elif test "x$with_company_name" != x; then
++    COMPANY_NAME="$with_company_name"
++  fi
++
+   # The vendor name, if any
+   AC_ARG_WITH(vendor-name, [AS_HELP_STRING([--with-vendor-name],
+       [Set vendor name. Among others, used to set the 'java.vendor'
+diff --git a/jdk/make/gensrc/GensrcMisc.gmk b/jdk/make/gensrc/GensrcMisc.gmk
+index 0e3dee5ca3..c137f371c7 100644
+--- a/jdk/make/gensrc/GensrcMisc.gmk
++++ b/jdk/make/gensrc/GensrcMisc.gmk
+@@ -30,6 +30,11 @@ include ProfileNames.gmk
+ # string and the runtime name into the Version.java file.
+ # To be printed by java -version
+ 
++company_name =
++ifneq ($(COMPANY_NAME),N/A)
++  company_name=($(COMPANY_NAME))
++endif
++
+ $(JDK_OUTPUTDIR)/gensrc/sun/misc/Version.java \
+ $(PROFILE_VERSION_JAVA_TARGETS): \
+     $(JDK_TOPDIR)/src/share/classes/sun/misc/Version.java.template
+@@ -40,6 +45,7 @@ $(PROFILE_VERSION_JAVA_TARGETS): \
+ 	    -e 's/@@java_version@@/$(RELEASE)/g' \
+ 	    -e 's/@@java_runtime_version@@/$(FULL_VERSION)/g' \
+ 	    -e 's/@@java_runtime_name@@/$(RUNTIME_NAME)/g' \
++	    -e 's/@@company_name@@/$(company_name)/g' \
+ 	    -e 's/@@java_profile_name@@/$(call profile_version_name, $@)/g' \
+ 	    $< > $@.tmp
+ 	$(MV) $@.tmp $@
+diff --git a/jdk/src/share/classes/sun/misc/Version.java.template b/jdk/src/share/classes/sun/misc/Version.java.template
+index 32e2586e79..b1642d3f0a 100644
+--- a/jdk/src/share/classes/sun/misc/Version.java.template
++++ b/jdk/src/share/classes/sun/misc/Version.java.template
+@@ -44,6 +44,9 @@ public class Version {
+     private static final String java_runtime_version =
+         "@@java_runtime_version@@";
+ 
++    private static final String company_name =
++        "@@company_name@@";
++
+     static {
+         init();
+     }
+@@ -103,7 +106,7 @@ public class Version {
+ 
+         /* Second line: runtime version (ie, libraries). */
+ 
+-        ps.print(java_runtime_name + " (build " + java_runtime_version);
++        ps.print(java_runtime_name + " " + company_name + "(build " + java_runtime_version);
+ 
+         if (java_profile_name.length() > 0) {
+             // profile name
+@@ -120,7 +123,7 @@ public class Version {
+         String java_vm_name    = System.getProperty("java.vm.name");
+         String java_vm_version = System.getProperty("java.vm.version");
+         String java_vm_info    = System.getProperty("java.vm.info");
+-        ps.println(java_vm_name + " (build " + java_vm_version + ", " +
++        ps.println(java_vm_name + " " + company_name + "(build " + java_vm_version + ", " +
+                    java_vm_info + ")");
+     }
+ 
+-- 
+2.7.4
diff --git a/patches/alpine-jdk8u/actions-ignore-branches.patch b/patches/alpine-jdk8u/actions-ignore-branches.patch
index e69de29..d110717 100644
--- a/patches/alpine-jdk8u/actions-ignore-branches.patch
+++ b/patches/alpine-jdk8u/actions-ignore-branches.patch
@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Adoptium <adoptium-mirrors@eclipse.org>
+Date: Mon, 17 Sep 2001 00:00:00 +0000
+Subject: [PATCH] skip github actions builds to save executors
+
+---
+ .github/workflows/submit.yml | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/.github/workflows/submit.yml b/.github/workflows/submit.yml
+index 72e619aa83..887a20c844 100644
+--- a/.github/workflows/submit.yml
++++ b/.github/workflows/submit.yml
+@@ -4,6 +4,8 @@ on:
+   push:
+     branches-ignore:
+       - master
++      - dev*
++      - release*
+       - pr/*
+   workflow_dispatch:
+     inputs:
+-- 
+2.39.0
diff --git a/patches/jdk8u/0001-Set-vendor-information.patch b/patches/jdk8u/0001-Set-vendor-information.patch
index af00f6e..0d2f8eb 100644
--- a/patches/jdk8u/0001-Set-vendor-information.patch
+++ b/patches/jdk8u/0001-Set-vendor-information.patch
@@ -8,22 +8,25 @@ Subject: [PATCH] Set vendor information
  1 file changed, 3 insertions(+), 3 deletions(-)
 
 diff --git a/jdk/src/share/native/java/lang/System.c b/jdk/src/share/native/java/lang/System.c
-index 5c36460..92cd3df 100644
+index 04ef657465..b06a38f87e 100644
 --- a/jdk/src/share/native/java/lang/System.c
 +++ b/jdk/src/share/native/java/lang/System.c
-@@ -109,9 +109,9 @@ Java_java_lang_System_identityHashCode(JNIEnv *env, jobject this, jobject x)
-     } else ((void) 0)
+@@ -110,13 +110,13 @@ Java_java_lang_System_identityHashCode(JNIEnv *env, jobject this, jobject x)
  
- #ifndef VENDOR /* Third party may overwrite this. */
+ /* Third party may overwrite these values. */
+ #ifndef VENDOR
 -#define VENDOR "Oracle Corporation"
--#define VENDOR_URL "http://java.oracle.com/"
--#define VENDOR_URL_BUG "http://bugreport.sun.com/bugreport/"
 +#define VENDOR "Eclipse Foundation"
+ #endif
+ #ifndef VENDOR_URL
+-#define VENDOR_URL "http://java.oracle.com/"
 +#define VENDOR_URL "https://adoptium.net/"
+ #endif
+ #ifndef VENDOR_URL_BUG
+-#define VENDOR_URL_BUG "http://bugreport.sun.com/bugreport/"
 +#define VENDOR_URL_BUG "https://github.com/adoptium/adoptium-support/issues"
  #endif
  
  #define JAVA_MAX_SUPPORTED_VERSION 52
 -- 
 2.7.4
-
diff --git a/patches/jdk8u/actions-ignore-branches.patch b/patches/jdk8u/actions-ignore-branches.patch
index e69de29..d110717 100644
--- a/patches/jdk8u/actions-ignore-branches.patch
+++ b/patches/jdk8u/actions-ignore-branches.patch
@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Adoptium <adoptium-mirrors@eclipse.org>
+Date: Mon, 17 Sep 2001 00:00:00 +0000
+Subject: [PATCH] skip github actions builds to save executors
+
+---
+ .github/workflows/submit.yml | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/.github/workflows/submit.yml b/.github/workflows/submit.yml
+index 72e619aa83..887a20c844 100644
+--- a/.github/workflows/submit.yml
++++ b/.github/workflows/submit.yml
+@@ -4,6 +4,8 @@ on:
+   push:
+     branches-ignore:
+       - master
++      - dev*
++      - release*
+       - pr/*
+   workflow_dispatch:
+     inputs:
+-- 
+2.39.0
diff --git a/patches/jdk8u/company_name.patch b/patches/jdk8u/company_name.patch
index da7f816..2095e5d 100644
--- a/patches/jdk8u/company_name.patch
+++ b/patches/jdk8u/company_name.patch
@@ -4,139 +4,16 @@ Date: Thu, 30 Aug 2018 14:22:52 +0100
 Subject: [PATCH] Allow setting company name
 
 ---
- common/autoconf/autogen.sh                    |  0
- common/autoconf/generated-configure.sh        | 35 +++++++++++++++++--
- common/autoconf/jdk-options.m4                | 13 ++++++-
- configure                                     |  0
- jdk/make/gensrc/GensrcMisc.gmk                |  6 ++++
- .../classes/sun/misc/Version.java.template    |  7 ++--
- 6 files changed, 55 insertions(+), 6 deletions(-)
- mode change 100644 => 100755 common/autoconf/autogen.sh
- mode change 100644 => 100755 configure
+ common/autoconf/jdk-options.m4                       | 11 +++++++++++
+ jdk/make/gensrc/GensrcMisc.gmk                       |  6 ++++++
+ jdk/src/share/classes/sun/misc/Version.java.template |  7 +++++--
+ 3 files changed, 22 insertions(+), 2 deletions(-)
 
-diff --git a/common/autoconf/autogen.sh b/common/autoconf/autogen.sh
-old mode 100644
-new mode 100755
-diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
-index c9992e4c8a..caf4963a93 100644
---- a/common/autoconf/generated-configure.sh
-+++ b/common/autoconf/generated-configure.sh
-@@ -822,9 +822,9 @@ COOKED_BUILD_NUMBER
- COOKED_JDK_UPDATE_VERSION
- JDK_VERSION
- COPYRIGHT_YEAR
-+COMPANY_NAME
- MACOSX_BUNDLE_ID_BASE
- MACOSX_BUNDLE_NAME_BASE
--COMPANY_NAME
- JDK_RC_PLATFORM_NAME
- PRODUCT_SUFFIX
- PRODUCT_NAME
-@@ -1004,6 +1004,7 @@ infodir
- docdir
- oldincludedir
- includedir
-+runstatedir
- localstatedir
- sharedstatedir
- sysconfdir
-@@ -1054,6 +1055,7 @@ with_milestone
- with_update_version
- with_user_release_suffix
- with_build_number
-+with_company_name
- with_copyright_year
- with_boot_jdk
- with_boot_jdk_jvmargs
-@@ -1237,6 +1239,7 @@ datadir='${datarootdir}'
- sysconfdir='${prefix}/etc'
- sharedstatedir='${prefix}/com'
- localstatedir='${prefix}/var'
-+runstatedir='${localstatedir}/run'
- includedir='${prefix}/include'
- oldincludedir='/usr/include'
- docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
-@@ -1489,6 +1492,15 @@ do
-   | -silent | --silent | --silen | --sile | --sil)
-     silent=yes ;;
- 
-+  -runstatedir | --runstatedir | --runstatedi | --runstated \
-+  | --runstate | --runstat | --runsta | --runst | --runs \
-+  | --run | --ru | --r)
-+    ac_prev=runstatedir ;;
-+  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
-+  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
-+  | --run=* | --ru=* | --r=*)
-+    runstatedir=$ac_optarg ;;
-+
-   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
-     ac_prev=sbindir ;;
-   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
-@@ -1626,7 +1638,7 @@ fi
- for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
- 		datadir sysconfdir sharedstatedir localstatedir includedir \
- 		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
--		libdir localedir mandir
-+		libdir localedir mandir runstatedir
- do
-   eval ac_val=\$$ac_var
-   # Remove trailing slashes.
-@@ -1779,6 +1791,7 @@ Fine tuning of the installation directories:
-   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
-   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
-   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
-+  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
-   --libdir=DIR            object code libraries [EPREFIX/lib]
-   --includedir=DIR        C header files [PREFIX/include]
-   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
-@@ -1884,6 +1897,7 @@ Optional Packages:
-                           Add a custom string to the version string if build
-                           number isn't set.[username_builddateb00]
-   --with-build-number     Set build number value for build [b00]
-+  --with-company-name     Set company name.
-   --with-copyright-year   Set copyright year value for build [current year]
-   --with-boot-jdk         path to Boot JDK (used to bootstrap build) [probed]
-   --with-boot-jdk-jvmargs specify JVM arguments to be passed to all
-@@ -4336,7 +4350,7 @@ VS_SDK_PLATFORM_NAME_2017=
- #CUSTOM_AUTOCONF_INCLUDE
- 
- # Do not change or remove the following line, it is needed for consistency checks:
--DATE_WHEN_GENERATED=1523388104
-+DATE_WHEN_GENERATED=1536947420
- 
- ###############################################################################
- #
-@@ -19843,6 +19857,21 @@ fi
- 
- 
- 
-+  # The company name, if any
-+
-+# Check whether --with-company-name was given.
-+if test "${with_company_name+set}" = set; then :
-+  withval=$with_company_name;
-+fi
-+
-+  if test "x$with_company_name" = xyes; then
-+    as_fn_error $? "--with-company-name must have a value" "$LINENO" 5
-+  elif  ! [[ $with_company_name =~ ^[[:print:]]*$ ]] ; then
-+    as_fn_error $? "--with-company-name contains non-printing characters: $with_company_name" "$LINENO" 5
-+  elif test "x$with_company_name" != x; then
-+    COMPANY_NAME="$with_company_name"
-+  fi
-+
- 
- 
- # Check whether --with-copyright-year was given.
 diff --git a/common/autoconf/jdk-options.m4 b/common/autoconf/jdk-options.m4
-index 6829d7af30..35e04f3342 100644
+index 18ba585209..ae9d5308f4 100644
 --- a/common/autoconf/jdk-options.m4
 +++ b/common/autoconf/jdk-options.m4
-@@ -509,10 +509,21 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_JDK_VERSION_NUMBERS],
-   AC_SUBST(PRODUCT_NAME)
-   AC_SUBST(PRODUCT_SUFFIX)
-   AC_SUBST(JDK_RC_PLATFORM_NAME)
--  AC_SUBST(COMPANY_NAME)
+@@ -539,6 +539,17 @@ AC_DEFUN_ONCE([JDKOPT_SETUP_JDK_VERSION_NUMBERS],
    AC_SUBST(MACOSX_BUNDLE_NAME_BASE)
    AC_SUBST(MACOSX_BUNDLE_ID_BASE)
  
@@ -150,16 +27,12 @@ index 6829d7af30..35e04f3342 100644
 +  elif test "x$with_company_name" != x; then
 +    COMPANY_NAME="$with_company_name"
 +  fi
-+  AC_SUBST(COMPANY_NAME)
 +
-   AC_ARG_WITH(copyright-year, [AS_HELP_STRING([--with-copyright-year],
-       [Set copyright year value for build @<:@current year@:>@])])
-   if test "x$with_copyright_year" = xyes; then
-diff --git a/configure b/configure
-old mode 100644
-new mode 100755
+   # The vendor name, if any
+   AC_ARG_WITH(vendor-name, [AS_HELP_STRING([--with-vendor-name],
+       [Set vendor name. Among others, used to set the 'java.vendor'
 diff --git a/jdk/make/gensrc/GensrcMisc.gmk b/jdk/make/gensrc/GensrcMisc.gmk
-index 9db5c9d6f7..0903ed642d 100644
+index 0e3dee5ca3..c137f371c7 100644
 --- a/jdk/make/gensrc/GensrcMisc.gmk
 +++ b/jdk/make/gensrc/GensrcMisc.gmk
 @@ -30,6 +30,11 @@ include ProfileNames.gmk
@@ -174,14 +47,14 @@ index 9db5c9d6f7..0903ed642d 100644
  $(JDK_OUTPUTDIR)/gensrc/sun/misc/Version.java \
  $(PROFILE_VERSION_JAVA_TARGETS): \
      $(JDK_TOPDIR)/src/share/classes/sun/misc/Version.java.template
-@@ -41,6 +46,7 @@ $(PROFILE_VERSION_JAVA_TARGETS): \
+@@ -40,6 +45,7 @@ $(PROFILE_VERSION_JAVA_TARGETS): \
+ 	    -e 's/@@java_version@@/$(RELEASE)/g' \
  	    -e 's/@@java_runtime_version@@/$(FULL_VERSION)/g' \
  	    -e 's/@@java_runtime_name@@/$(RUNTIME_NAME)/g' \
- 	    -e 's/@@java_profile_name@@/$(call profile_version_name, $@)/g' \
 +	    -e 's/@@company_name@@/$(company_name)/g' \
+ 	    -e 's/@@java_profile_name@@/$(call profile_version_name, $@)/g' \
  	    $< > $@.tmp
  	$(MV) $@.tmp $@
- 
 diff --git a/jdk/src/share/classes/sun/misc/Version.java.template b/jdk/src/share/classes/sun/misc/Version.java.template
 index 32e2586e79..b1642d3f0a 100644
 --- a/jdk/src/share/classes/sun/misc/Version.java.template
@@ -214,3 +87,5 @@ index 32e2586e79..b1642d3f0a 100644
                     java_vm_info + ")");
      }
  
+-- 
+2.7.4
diff --git a/skaraMirror.sh b/skaraMirror.sh
index 4ef8cbe..93b0153 100755
--- a/skaraMirror.sh
+++ b/skaraMirror.sh
@@ -407,7 +407,6 @@ function performMergeIntoDevFromMaster() {
 checkArgs $#
 
 GITHUB_REPO="$1"
-REPO=${2:-"git@github.com:adoptium/$GITHUB_REPO"}
 
 # alpine-jdk8u mirrors from the upstream jdk8u Skara repo
 if [[ "${GITHUB_REPO}" == "alpine-jdk8u" ]]; then
@@ -416,6 +415,13 @@ else
   SKARA_REPO="https://github.com/openjdk/${GITHUB_REPO}"
 fi
 
+# aarch32-port-jdk8u mirrors to the Adoptium repo named aarch32-jdk8u (without the "port-" prefix)
+if [[ "${GITHUB_REPO}" == "aarch32-port-jdk8u" ]]; then
+  REPO=${2:-"git@github.com:adoptium/aarch32-jdk8u"}
+else
+  REPO=${2:-"git@github.com:adoptium/$GITHUB_REPO"}
+fi
+
 # Determine the default branch of the upstream Skara repo via git ls-remote (no API token needed)
 SKARA_DEFAULT_BRANCH=$(git ls-remote --symref "${SKARA_REPO}" HEAD | grep '^ref:' | sed 's|ref: refs/heads/||;s/[[:space:]].*//' | tr -d '[:space:]')
 if [[ -z "${SKARA_DEFAULT_BRANCH}" ]]; then

From a9927b625031b745c500b0355a8819e79f7b05b7 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Fri, 28 Aug 2026 09:00:17 +0100
Subject: [PATCH 19/27] fix(mirror_cspu): exclude +0 and -b00 fork tags and
 filter aarch32-only tags

Co-authored-by: Bob <bob@ibm.com>
---
 skaraMirror.sh | 18 +++++++++++++++---
 1 file changed, 15 insertions(+), 3 deletions(-)

diff --git a/skaraMirror.sh b/skaraMirror.sh
index 93b0153..01db372 100755
--- a/skaraMirror.sh
+++ b/skaraMirror.sh
@@ -462,7 +462,11 @@ fi
 jdk11plus_tag_sort1="sort -t+ -k2,2n"
 # Second, (stable) sort on (V), (W), (X), (P): P(Patch) is optional and defaulted to "0"
 jdk11plus_tag_sort2="sort -t. -k2,2n -k3,3n -k4,4n -k5,5n"
-# Ignore "..+0" branch fork point tags 
+# Ignore "..+0" branch fork point tags — these mark where the next version branched off master
+# and are not real builds. Build tags for the next version (e.g. jdk-21.0.15+1) only appear on
+# that new branch, never on master, so +0 is always the last visible tag for that version on
+# master. Including it would advance currentReleaseTag past any not-yet-tagged current-version
+# builds (e.g. jdk-21.0.14 GA), permanently locking them out of the merge loop.
 jdk11plus_sort_tags_cmd="grep -v _adopt | grep -v '\+0$' | sed 's/jdk-/jdk./g' | sed 's/+/.0.0+/g' | $jdk11plus_tag_sort1 | nl -n rz | $jdk11plus_tag_sort2 | sed 's/\.0\.0+/+/g' | cut -f2- | sed 's/jdk./jdk-/g'"
 
 # JDK8 tag sorting:
@@ -472,8 +476,9 @@ jdk11plus_sort_tags_cmd="grep -v _adopt | grep -v '\+0$' | sed 's/jdk-/jdk./g' |
 jdk8_tag_sort1="sort -tb -k2,2n"
 # Second, (stable) sort on (V), (W)
 jdk8_tag_sort2="sort -tu -k2,2n"
-# Ignore "..-b00" branch fork point tags
-jdk8_sort_tags_cmd="grep -v _adopt | grep -v '\-b00$' | $jdk8_tag_sort1 | nl -n rz | $jdk8_tag_sort2  | cut -f2-"
+# Ignore "..-b00" branch fork point tags (same reasoning as jdk11+ above).
+# Note: no "$" anchor — aarch32 tags embed -b00 mid-string, e.g. jdk8u504-b00-aarch32-20260731.
+jdk8_sort_tags_cmd="grep -v _adopt | grep -v '\-b00' | $jdk8_tag_sort1 | nl -n rz | $jdk8_tag_sort2  | cut -f2-"
 
 
 if [[ "${VERSION}" == "8" ]]; then
@@ -482,6 +487,13 @@ else
   jdk_sort_tags_cmd="${jdk11plus_sort_tags_cmd}"
 fi
 
+# For aarch32-port-jdk8u, the upstream Skara repo also contains non-aarch32 tags (inherited from
+# the parent jdk8u repo). Prepend a filter so only tags containing "aarch32" are considered —
+# this prevents non-aarch32 tags from being picked as the branch-point or merged into release/dev.
+if [[ "${GITHUB_REPO}" == "aarch32-port-jdk8u" ]]; then
+  jdk_sort_tags_cmd="grep 'aarch32' | ${jdk_sort_tags_cmd}"
+fi
+
 cloneGitHubRepo
 addSkaralUpstream
 performMergeFromSkaraIntoGit

From 3144e2106880fb7a2afb497bf1f9b253a552c361 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Fri, 28 Aug 2026 09:49:01 +0100
Subject: [PATCH 20/27] refactor(mirror_cspu): replace JDK_VERSION param with
 SKARA_REPO and add Slack failure alerts

Co-authored-by: Bob <bob@ibm.com>
---
 Jenkinsfile | 26 ++++++++++++++++++++------
 1 file changed, 20 insertions(+), 6 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index e9b9ebd..236725a 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -27,8 +27,8 @@ pipeline {
         stage('Validate Parameters') {
             steps {
                 script {
-                    if (!params.JDK_VERSION?.trim()) {
-                        error('JDK_VERSION parameter is required.')
+                    if (!params.SKARA_REPO?.trim()) {
+                        error('SKARA_REPO parameter is required.')
                     }
                 }
             }
@@ -37,7 +37,7 @@ pipeline {
         stage('Determine Branches') {
             steps {
                 script {
-                    def skaraRepo = "https://github.com/openjdk/${params.JDK_VERSION}"
+                    def skaraRepo = "https://github.com/openjdk/${params.SKARA_REPO}"
                     echo "Upstream SKARA_REPO: ${skaraRepo}"
 
                     // Determine default branch via git ls-remote --symref (no API token needed)
@@ -54,7 +54,7 @@ pipeline {
 
                     // Do a temporary bare clone with --filter=blob:none to get branch refs and
                     // commit dates without downloading any file content.
-                    def tmpBareClone = "${env.WORKSPACE}/tmp-bare-${params.JDK_VERSION}"
+                    def tmpBareClone = "${env.WORKSPACE}/tmp-bare-${params.SKARA_REPO}"
                     sh "rm -rf '${tmpBareClone}'"
                     sh "git clone --bare --filter=blob:none '${skaraRepo}' '${tmpBareClone}'"
 
@@ -119,7 +119,7 @@ pipeline {
             }
             steps {
                 script {
-                    def workspaceDir = "${env.WORKSPACE}/workspace/${params.JDK_VERSION}"
+                    def workspaceDir = "${env.WORKSPACE}/workspace/${params.SKARA_REPO}"
                     echo "Cleaning mirror workspace: ${workspaceDir}"
                     sh "rm -rf '${workspaceDir}'"
                 }
@@ -137,7 +137,7 @@ pipeline {
                         withEnv(["BRANCH=${branch}"]) {
                             sh """
                                 git --version
-                                bash ./skaraMirror.sh '${params.JDK_VERSION}' ${mirrorRepoArg ? "'${mirrorRepoArg}'" : ''}
+                                bash ./skaraMirror.sh '${params.SKARA_REPO}' ${mirrorRepoArg ? "'${mirrorRepoArg}'" : ''}
                             """
                         }
                     }
@@ -158,6 +158,20 @@ pipeline {
         }
         failure {
             echo 'Mirror job failed.'
+            script {
+                // Only notify Slack during 09:00–11:59 UTC to avoid hourly spam.
+                def utcHour = sh(script: "date -u +%H", returnStdout: true).trim().toInteger()
+                if (utcHour >= 9 && utcHour < 12) {
+                    slackSend(
+                        channel: '#build',
+                        color: 'danger',
+                        message: "Skara mirror job *FAILED* for `${params.SKARA_REPO ?: 'unknown'}` " +
+                                 "(<${env.BUILD_URL}console|Console>)"
+                    )
+                } else {
+                    echo "Outside Slack notification window (UTC hour: ${utcHour}) — skipping Slack alert."
+                }
+            }
         }
         aborted {
             echo 'Mirror job was aborted.'

From b4b10f1b19a5cc45ee40b4198e4b100e5c43d810 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Fri, 28 Aug 2026 09:53:45 +0100
Subject: [PATCH 21/27] fix(mirror_cspu): include mirror repo in Slack failure
 message

Co-authored-by: Bob <bob@ibm.com>
---
 Jenkinsfile | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 236725a..48a6a29 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -165,8 +165,9 @@ pipeline {
                     slackSend(
                         channel: '#build',
                         color: 'danger',
-                        message: "Skara mirror job *FAILED* for `${params.SKARA_REPO ?: 'unknown'}` " +
-                                 "(<${env.BUILD_URL}console|Console>)"
+                        message: "Skara mirror job *FAILED* for `${params.SKARA_REPO ?: 'unknown'}`" +
+                                 (params.ADOPTIUM_MIRROR_REPO?.trim() ? " → `${params.ADOPTIUM_MIRROR_REPO}`" : '') +
+                                 " (<${env.BUILD_URL}console|Console>)"
                     )
                 } else {
                     echo "Outside Slack notification window (UTC hour: ${utcHour}) — skipping Slack alert."

From 0efc4b3677ba861f1a595db786213291ef5c9ceb Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Fri, 28 Aug 2026 10:26:16 +0100
Subject: [PATCH 22/27] fix(mirror_cspu): skip upstream pr/ branches during
 mirror sync

Co-authored-by: Bob <bob@ibm.com>
---
 Jenkinsfile | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/Jenkinsfile b/Jenkinsfile
index 48a6a29..8467771 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -83,6 +83,8 @@ pipeline {
                         for (branch in allBranchesRaw.split('\n')) {
                             branch = branch.trim()
                             if (!branch) continue
+                            // Skip upstream PR branches — there can be hundreds and they are not mirrored
+                            if (branch.startsWith('pr/')) continue
                             def commitEpochStr = sh(
                                 script: "git -C '${tmpBareClone}' log -1 --format='%ct' '${branch}'",
                                 returnStdout: true

From ec1252383ceb3c545796666f037f3756dd37cd26 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <31470007+andrew-m-leonard@users.noreply.github.com>
Date: Fri, 28 Aug 2026 11:11:43 +0100
Subject: [PATCH 23/27] Apply suggestions from code review

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
 Jenkinsfile | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 8467771..61ff4b2 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -30,6 +30,9 @@ pipeline {
                     if (!params.SKARA_REPO?.trim()) {
                         error('SKARA_REPO parameter is required.')
                     }
+                    if (!(params.SKARA_REPO ==~ /[A-Za-z0-9._-]+/)) {
+                        error('SKARA_REPO must be a valid GitHub repository name.')
+                    }
                 }
             }
         }
@@ -37,7 +40,8 @@ pipeline {
         stage('Determine Branches') {
             steps {
                 script {
-                    def skaraRepo = "https://github.com/openjdk/${params.SKARA_REPO}"
+                    def upstreamRepo = params.SKARA_REPO == 'alpine-jdk8u' ? 'jdk8u' : params.SKARA_REPO
+                    def skaraRepo = "https://github.com/openjdk/${upstreamRepo}"
                     echo "Upstream SKARA_REPO: ${skaraRepo}"
 
                     // Determine default branch via git ls-remote --symref (no API token needed)

From 69e2c012f272c80c54fe1ecf8eb28cf21517cbb3 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Fri, 28 Aug 2026 11:32:34 +0100
Subject: [PATCH 24/27] chore(mirror_cspu): regenerate generated-configure.sh
 and remove bundled patch section

Co-authored-by: Bob <bob@ibm.com>
---
 ...ply-PATCH-Allow-setting-company-name.patch | 57 +------------------
 ...hub-actions-builds-to-save-executors.patch | 26 ---------
 skaraMirror.sh                                | 24 ++++++++
 3 files changed, 26 insertions(+), 81 deletions(-)
 delete mode 100644 patches/alpine-jdk8u/0004-skip-github-actions-builds-to-save-executors.patch

diff --git a/patches/alpine-jdk8u/0002-apply-PATCH-Allow-setting-company-name.patch b/patches/alpine-jdk8u/0002-apply-PATCH-Allow-setting-company-name.patch
index 9faf367..279192e 100644
--- a/patches/alpine-jdk8u/0002-apply-PATCH-Allow-setting-company-name.patch
+++ b/patches/alpine-jdk8u/0002-apply-PATCH-Allow-setting-company-name.patch
@@ -4,63 +4,11 @@ Date: Mon, 6 Dec 2021 11:26:48 +0000
 Subject: [PATCH] apply [PATCH] Allow setting company name
 
 ---
- common/autoconf/generated-configure.sh        | 24 +++++++++++--------
  common/autoconf/jdk-options.m4                | 12 ++++++++++
  jdk/make/gensrc/GensrcMisc.gmk                |  6 +++++
  .../classes/sun/misc/Version.java.template    |  7 ++++--
- 4 files changed, 37 insertions(+), 12 deletions(-)
+ 3 files changed, 23 insertions(+), 2 deletions(-)
 
-diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
-index 71fabf4dbb..c926f7d75e 100644
---- a/common/autoconf/generated-configure.sh
-+++ b/common/autoconf/generated-configure.sh
-@@ -1067,6 +1067,7 @@ with_milestone
- with_update_version
- with_user_release_suffix
- with_build_number
-+with_company_name
- with_vendor_name
- with_vendor_url
- with_vendor_bug_url
-@@ -1918,6 +1919,7 @@ Optional Packages:
-                           Add a custom string to the version string if build
-                           number isn't set.[username_builddateb00]
-   --with-build-number     Set build number value for build [b00]
-+  --with-company-name     Set company name
-   --with-vendor-name      Set vendor name. Among others, used to set the
-                           'java.vendor' and 'java.vm.vendor' system
-                           properties. [not specified]
-@@ -20138,18 +20140,20 @@ fi
- 
-   # Now set the JDK version, milestone, build number etc.
- 
-+  # The company name, if any
- 
-+# Check whether --with-company-name was given.
-+if test "${with_company_name+set}" = set; then :
-+  withval=$with_company_name;
-+fi
- 
--
--
--
--
--
--
--
--
--
--
-+  if test "x$with_company_name" = xyes; then
-+    as_fn_error $? "--with-company-name must have a value" "$LINENO" 5
-+  elif  ! [[ $with_company_name =~ ^[[:print:]]*$ ]] ; then
-+    as_fn_error $? "--with-company-name contains non-printing characters: $with_company_name" "$LINENO" 5
-+  elif test "x$with_company_name" != x; then
-+    COMPANY_NAME="$with_company_name"
-+  fi
- 
-   # The vendor name, if any
- 
 diff --git a/common/autoconf/jdk-options.m4 b/common/autoconf/jdk-options.m4
 index 18ba585209..42aeb7bd61 100644
 --- a/common/autoconf/jdk-options.m4
@@ -137,9 +85,8 @@ index 32e2586e79..b1642d3f0a 100644
          String java_vm_info    = System.getProperty("java.vm.info");
 -        ps.println(java_vm_name + " (build " + java_vm_version + ", " +
 +        ps.println(java_vm_name + " " + company_name + "(build " + java_vm_version + ", " +
-                    java_vm_info + ")");
+                     java_vm_info + ")");
      }
  
 -- 
 2.52.0
-
diff --git a/patches/alpine-jdk8u/0004-skip-github-actions-builds-to-save-executors.patch b/patches/alpine-jdk8u/0004-skip-github-actions-builds-to-save-executors.patch
deleted file mode 100644
index 2a90884..0000000
--- a/patches/alpine-jdk8u/0004-skip-github-actions-builds-to-save-executors.patch
+++ /dev/null
@@ -1,26 +0,0 @@
-From c7c6920811bf5efda3111893fa335d4f4dd0a495 Mon Sep 17 00:00:00 2001
-From: George Adams <georgeadams1995@gmail.com>
-Date: Thu, 12 Jan 2023 22:16:09 +0000
-Subject: [PATCH] skip github actions builds to save executors
-
-Currently, every time the mirror job runs we end up running GitHub actions builds on all platforms for every commit on both dev and release which ends up burning through our allowance. This PR adds the branches-ignore flag to both branches as we know the code is safe from master.
----
- .github/workflows/submit.yml | 2 ++
- 1 file changed, 2 insertions(+)
-
-diff --git a/.github/workflows/submit.yml b/.github/workflows/submit.yml
-index 87e49481f5..e998d6fe90 100644
---- a/.github/workflows/submit.yml
-+++ b/.github/workflows/submit.yml
-@@ -4,6 +4,8 @@ on:
-   push:
-     branches-ignore:
-       - master
-+      - dev*
-+      - release*
-       - pr/*
-   workflow_dispatch:
-     inputs:
--- 
-2.52.0
-
diff --git a/skaraMirror.sh b/skaraMirror.sh
index 01db372..392c89b 100755
--- a/skaraMirror.sh
+++ b/skaraMirror.sh
@@ -212,6 +212,30 @@ function performMergeIntoReleaseFromMaster() {
       done
     fi
 
+    # For JDK 8 repos, regenerate generated-configure.sh after all patches have been applied.
+    # company_name.patch modifies jdk-options.m4 but does not include the generated file
+    # (unlike the alpine-jdk8u variant which bundles both). The JDK 8 configure wrapper
+    # runs the checked-in generated script, so without regeneration --with-company-name
+    # is unavailable at build time. autogen.sh is idempotent — if the patch already
+    # included the generated file (e.g. alpine-jdk8u/0002) this produces no diff.
+    if [[ "${VERSION}" == "8" ]]; then
+      local AUTOGEN="common/autoconf/autogen.sh"
+      local GENERATED="common/autoconf/generated-configure.sh"
+      if [ -f "$AUTOGEN" ]; then
+        echo "Regenerating $GENERATED after patch application"
+        bash "$AUTOGEN" || exit 1
+        if ! git diff --quiet "$GENERATED" ; then
+          git add "$GENERATED"
+          git commit --no-edit -m "Regenerate generated-configure.sh after Adoptium patches" || exit 1
+          echo "Committed regenerated $GENERATED"
+        else
+          echo "$GENERATED already up to date, no commit needed"
+        fi
+      else
+        echo "WARNING: $AUTOGEN not found — skipping $GENERATED regeneration"
+      fi
+    fi
+
     # If this is a brand new release branch, tag the base build tag with _adopt now that
     # patches have been applied — the merge loop below will find no new tags to process
     if [[ -n "$NEW_RELEASE_BRANCH_TAG" ]]; then

From 9d416d3d896c35efcf628fbad1c217326d9ceb1b Mon Sep 17 00:00:00 2001
From: Andrew Leonard <31470007+andrew-m-leonard@users.noreply.github.com>
Date: Fri, 28 Aug 2026 13:38:58 +0100
Subject: [PATCH 25/27] Apply suggestions from code review

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
 Jenkinsfile | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/Jenkinsfile b/Jenkinsfile
index 61ff4b2..f483e0b 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -89,10 +89,12 @@ pipeline {
                             if (!branch) continue
                             // Skip upstream PR branches — there can be hundreds and they are not mirrored
                             if (branch.startsWith('pr/')) continue
-                            def commitEpochStr = sh(
-                                script: "git -C '${tmpBareClone}' log -1 --format='%ct' '${branch}'",
-                                returnStdout: true
-                            ).trim()
+                            def commitEpochStr = withEnv(["BRANCH_TO_CHECK=${branch}"]) {
+                                sh(
+                                    script: "git -C '${tmpBareClone}' log -1 --format='%ct' -- \"\$BRANCH_TO_CHECK\"",
+                                    returnStdout: true
+                                ).trim()
+                            }
                             if (!commitEpochStr.isLong()) {
                                 error("Could not determine commit date for branch '${branch}': unexpected output: '${commitEpochStr}'")
                             }
@@ -140,11 +142,15 @@ pipeline {
 
                     for (branch in branchList) {
                         echo "--- Mirroring branch: ${branch} ---"
-                        withEnv(["BRANCH=${branch}"]) {
-                            sh """
+                        withEnv([
+                            "BRANCH=${branch}",
+                            "SKARA_REPO_ARG=${params.SKARA_REPO}",
+                            "MIRROR_REPO_ARG=${mirrorRepoArg}"
+                        ]) {
+                            sh '''
                                 git --version
-                                bash ./skaraMirror.sh '${params.SKARA_REPO}' ${mirrorRepoArg ? "'${mirrorRepoArg}'" : ''}
-                            """
+                                bash ./skaraMirror.sh "$SKARA_REPO_ARG" "$MIRROR_REPO_ARG"
+                            '''
                         }
                     }
                 }

From 9fb233a03faeb0a194fca1e83b1c023dc5086adf Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Fri, 28 Aug 2026 13:42:57 +0100
Subject: [PATCH 26/27] chore(mirror_cspu): update alpine musl libc patch to
 remove bundled generated-configure.sh changes

Co-authored-by: Bob <bob@ibm.com>
---
 .../0005-alpine-musl-libc-support.patch       | 40498 ----------------
 1 file changed, 40498 deletions(-)

diff --git a/patches/alpine-jdk8u/0005-alpine-musl-libc-support.patch b/patches/alpine-jdk8u/0005-alpine-musl-libc-support.patch
index 3f014a6..ebe3ea6 100644
--- a/patches/alpine-jdk8u/0005-alpine-musl-libc-support.patch
+++ b/patches/alpine-jdk8u/0005-alpine-musl-libc-support.patch
@@ -75,40504 +75,6 @@ index 5d1ef8732f..006067fa73 100644
    LEGACY_HOST_LDFLAGS="$LEGACY_HOST_LDFLAGS $with_extra_ldflags"
    LEGACY_TARGET_LDFLAGS="$LEGACY_TARGET_LDFLAGS $with_extra_ldflags"
    LEGACY_HOST_ASFLAGS="$with_extra_asflags"
-diff --git a/common/autoconf/generated-configure.sh b/common/autoconf/generated-configure.sh
-index 344c31649b..9998650ded 100644
---- a/common/autoconf/generated-configure.sh
-+++ b/common/autoconf/generated-configure.sh
-@@ -6,12 +6,13 @@
- #
- #! /bin/sh
- # Guess values for system-dependent variables and create Makefiles.
--# Generated by GNU Autoconf 2.69 for OpenJDK jdk8.
-+# Generated by GNU Autoconf 2.72 for OpenJDK jdk8.
- #
- # Report bugs to <build-dev@openjdk.java.net>.
- #
- #
--# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
-+# Copyright (C) 1992-1996, 1998-2017, 2020-2023 Free Software Foundation,
-+# Inc.
- #
- #
- # This configure script is free software; the Free Software Foundation
-@@ -22,63 +23,65 @@
- 
- # Be more Bourne compatible
- DUALCASE=1; export DUALCASE # for MKS sh
--if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
-+if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
-+then :
-   emulate sh
-   NULLCMD=:
-   # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
-   # is contrary to our usage.  Disable this feature.
-   alias -g '${1+"$@"}'='"$@"'
-   setopt NO_GLOB_SUBST
--else
--  case `(set -o) 2>/dev/null` in #(
-+else case e in #(
-+  e) case `(set -o) 2>/dev/null` in #(
-   *posix*) :
-     set -o posix ;; #(
-   *) :
-      ;;
-+esac ;;
- esac
- fi
- 
- 
-+
-+# Reset variables that may have inherited troublesome values from
-+# the environment.
-+
-+# IFS needs to be set, to space, tab, and newline, in precisely that order.
-+# (If _AS_PATH_WALK were called with IFS unset, it would have the
-+# side effect of setting IFS to empty, thus disabling word splitting.)
-+# Quoting is to prevent editors from complaining about space-tab.
- as_nl='
- '
- export as_nl
--# Printing a long string crashes Solaris 7 /usr/bin/printf.
--as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
--as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
--as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
--# Prefer a ksh shell builtin over an external printf program on Solaris,
--# but without wasting forks for bash or zsh.
--if test -z "$BASH_VERSION$ZSH_VERSION" \
--    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
--  as_echo='print -r --'
--  as_echo_n='print -rn --'
--elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
--  as_echo='printf %s\n'
--  as_echo_n='printf %s'
--else
--  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
--    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
--    as_echo_n='/usr/ucb/echo -n'
--  else
--    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
--    as_echo_n_body='eval
--      arg=$1;
--      case $arg in #(
--      *"$as_nl"*)
--	expr "X$arg" : "X\\(.*\\)$as_nl";
--	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
--      esac;
--      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
--    '
--    export as_echo_n_body
--    as_echo_n='sh -c $as_echo_n_body as_echo'
--  fi
--  export as_echo_body
--  as_echo='sh -c $as_echo_body as_echo'
--fi
-+IFS=" ""	$as_nl"
-+
-+PS1='$ '
-+PS2='> '
-+PS4='+ '
-+
-+# Ensure predictable behavior from utilities with locale-dependent output.
-+LC_ALL=C
-+export LC_ALL
-+LANGUAGE=C
-+export LANGUAGE
-+
-+# We cannot yet rely on "unset" to work, but we need these variables
-+# to be unset--not just set to an empty or harmless value--now, to
-+# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh).  This construct
-+# also avoids known problems related to "unset" and subshell syntax
-+# in other old shells (e.g. bash 2.01 and pdksh 5.2.14).
-+for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH
-+do eval test \${$as_var+y} \
-+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
-+done
-+
-+# Ensure that fds 0, 1, and 2 are open.
-+if (exec 3>&0) 2>/dev/null; then :; else exec 0</dev/null; fi
-+if (exec 3>&1) 2>/dev/null; then :; else exec 1>/dev/null; fi
-+if (exec 3>&2)            ; then :; else exec 2>/dev/null; fi
- 
- # The user is always right.
--if test "${PATH_SEPARATOR+set}" != set; then
-+if ${PATH_SEPARATOR+false} :; then
-   PATH_SEPARATOR=:
-   (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
-     (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
-@@ -87,13 +90,6 @@ if test "${PATH_SEPARATOR+set}" != set; then
- fi
- 
- 
--# IFS
--# We need space, tab and new line, in precisely that order.  Quoting is
--# there to prevent editors from complaining about space-tab.
--# (If _AS_PATH_WALK were called with IFS unset, it would disable word
--# splitting by setting IFS to empty value.)
--IFS=" ""	$as_nl"
--
- # Find who we are.  Look in the path if we contain no directory separator.
- as_myself=
- case $0 in #((
-@@ -102,43 +98,27 @@ case $0 in #((
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
--    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-+    test -r "$as_dir$0" && as_myself=$as_dir$0 && break
-   done
- IFS=$as_save_IFS
- 
-      ;;
- esac
--# We did not find ourselves, most probably we were run as `sh COMMAND'
-+# We did not find ourselves, most probably we were run as 'sh COMMAND'
- # in which case we are not to be found in the path.
- if test "x$as_myself" = x; then
-   as_myself=$0
- fi
- if test ! -f "$as_myself"; then
--  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-+  printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-   exit 1
- fi
- 
--# Unset variables that we do not need and which cause bugs (e.g. in
--# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
--# suppresses any "Segmentation fault" message there.  '((' could
--# trigger a bug in pdksh 5.2.14.
--for as_var in BASH_ENV ENV MAIL MAILPATH
--do eval test x\${$as_var+set} = xset \
--  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
--done
--PS1='$ '
--PS2='> '
--PS4='+ '
--
--# NLS nuisances.
--LC_ALL=C
--export LC_ALL
--LANGUAGE=C
--export LANGUAGE
--
--# CDPATH.
--(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
- 
- # Use a proper internal environment variable to ensure we don't fall
-   # into an infinite loop, continuously re-executing ourselves.
-@@ -159,26 +139,28 @@ case $- in # ((((
- esac
- exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
- # Admittedly, this is quite paranoid, since all the known shells bail
--# out after a failed `exec'.
--$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
--as_fn_exit 255
-+# out after a failed 'exec'.
-+printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
-+exit 255
-   fi
-   # We don't want this to propagate to other subprocesses.
-           { _as_can_reexec=; unset _as_can_reexec;}
- if test "x$CONFIG_SHELL" = x; then
--  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
-+  as_bourne_compatible="if test \${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
-+then :
-   emulate sh
-   NULLCMD=:
-   # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
-   # is contrary to our usage.  Disable this feature.
-   alias -g '\${1+\"\$@\"}'='\"\$@\"'
-   setopt NO_GLOB_SUBST
--else
--  case \`(set -o) 2>/dev/null\` in #(
-+else case e in #(
-+  e) case \`(set -o) 2>/dev/null\` in #(
-   *posix*) :
-     set -o posix ;; #(
-   *) :
-      ;;
-+esac ;;
- esac
- fi
- "
-@@ -193,42 +175,55 @@ as_fn_success || { exitcode=1; echo as_fn_success failed.; }
- as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
- as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
- as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
--if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
-+if ( set x; as_fn_ret_success y && test x = \"\$1\" )
-+then :
- 
--else
--  exitcode=1; echo positional parameters were not saved.
-+else case e in #(
-+  e) exitcode=1; echo positional parameters were not saved. ;;
-+esac
- fi
- test x\$exitcode = x0 || exit 1
-+blah=\$(echo \$(echo blah))
-+test x\"\$blah\" = xblah || exit 1
- test -x / || exit 1"
-   as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
-   as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
-   eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
-   test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
- test \$(( 1 + 1 )) = 2 || exit 1"
--  if (eval "$as_required") 2>/dev/null; then :
-+  if (eval "$as_required") 2>/dev/null
-+then :
-   as_have_required=yes
--else
--  as_have_required=no
-+else case e in #(
-+  e) as_have_required=no ;;
-+esac
- fi
--  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
-+  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null
-+then :
- 
--else
--  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-+else case e in #(
-+  e) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- as_found=false
- for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-   as_found=:
-   case $as_dir in #(
- 	 /*)
- 	   for as_base in sh bash ksh sh5; do
- 	     # Try only shells that exist, to save several forks.
--	     as_shell=$as_dir/$as_base
-+	     as_shell=$as_dir$as_base
- 	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
--		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
-+		    as_run=a "$as_shell" -c "$as_bourne_compatible""$as_required" 2>/dev/null
-+then :
-   CONFIG_SHELL=$as_shell as_have_required=yes
--		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
-+		   if as_run=a "$as_shell" -c "$as_bourne_compatible""$as_suggested" 2>/dev/null
-+then :
-   break 2
- fi
- fi
-@@ -236,14 +231,22 @@ fi
-        esac
-   as_found=false
- done
--$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
--	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
--  CONFIG_SHELL=$SHELL as_have_required=yes
--fi; }
- IFS=$as_save_IFS
-+if $as_found
-+then :
-+
-+else case e in #(
-+  e) if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
-+	      as_run=a "$SHELL" -c "$as_bourne_compatible""$as_required" 2>/dev/null
-+then :
-+  CONFIG_SHELL=$SHELL as_have_required=yes
-+fi ;;
-+esac
-+fi
- 
- 
--      if test "x$CONFIG_SHELL" != x; then :
-+      if test "x$CONFIG_SHELL" != x
-+then :
-   export CONFIG_SHELL
-              # We cannot yet assume a decent shell, so we have to provide a
- # neutralization value for shells without unset; and this also
-@@ -260,26 +263,28 @@ case $- in # ((((
- esac
- exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
- # Admittedly, this is quite paranoid, since all the known shells bail
--# out after a failed `exec'.
--$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
-+# out after a failed 'exec'.
-+printf "%s\n" "$0: could not re-execute with $CONFIG_SHELL" >&2
- exit 255
- fi
- 
--    if test x$as_have_required = xno; then :
--  $as_echo "$0: This script requires a shell more modern than all"
--  $as_echo "$0: the shells that I found on your system."
--  if test x${ZSH_VERSION+set} = xset ; then
--    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
--    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
-+    if test x$as_have_required = xno
-+then :
-+  printf "%s\n" "$0: This script requires a shell more modern than all"
-+  printf "%s\n" "$0: the shells that I found on your system."
-+  if test ${ZSH_VERSION+y} ; then
-+    printf "%s\n" "$0: In particular, zsh $ZSH_VERSION has bugs and should"
-+    printf "%s\n" "$0: be upgraded to zsh 4.3.4 or later."
-   else
--    $as_echo "$0: Please tell bug-autoconf@gnu.org and
-+    printf "%s\n" "$0: Please tell bug-autoconf@gnu.org and
- $0: build-dev@openjdk.java.net about your system, including
- $0: any error possibly output before this message. Then
- $0: install a modern shell, or manually run the script
- $0: under such a shell if you do have one."
-   fi
-   exit 1
--fi
-+fi ;;
-+esac
- fi
- fi
- SHELL=${CONFIG_SHELL-/bin/sh}
-@@ -300,6 +305,7 @@ as_fn_unset ()
- }
- as_unset=as_fn_unset
- 
-+
- # as_fn_set_status STATUS
- # -----------------------
- # Set $? to STATUS, without forking.
-@@ -331,7 +337,7 @@ as_fn_mkdir_p ()
-     as_dirs=
-     while :; do
-       case $as_dir in #(
--      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-+      *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-       *) as_qdir=$as_dir;;
-       esac
-       as_dirs="'$as_qdir' $as_dirs"
-@@ -340,7 +346,7 @@ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
- 	 X"$as_dir" : 'X\(//\)[^/]' \| \
- 	 X"$as_dir" : 'X\(//\)$' \| \
- 	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
--$as_echo X"$as_dir" |
-+printf "%s\n" X"$as_dir" |
-     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
- 	    s//\1/
- 	    q
-@@ -379,16 +385,18 @@ as_fn_executable_p ()
- # advantage of any shell optimizations that allow amortized linear growth over
- # repeated appends, instead of the typical quadratic growth present in naive
- # implementations.
--if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
-+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null
-+then :
-   eval 'as_fn_append ()
-   {
-     eval $1+=\$2
-   }'
--else
--  as_fn_append ()
-+else case e in #(
-+  e) as_fn_append ()
-   {
-     eval $1=\$$1\$2
--  }
-+  } ;;
-+esac
- fi # as_fn_append
- 
- # as_fn_arith ARG...
-@@ -396,16 +404,18 @@ fi # as_fn_append
- # Perform arithmetic evaluation on the ARGs, and store the result in the
- # global $as_val. Take advantage of shells that can avoid forks. The arguments
- # must be portable across $(()) and expr.
--if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
-+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null
-+then :
-   eval 'as_fn_arith ()
-   {
-     as_val=$(( $* ))
-   }'
--else
--  as_fn_arith ()
-+else case e in #(
-+  e) as_fn_arith ()
-   {
-     as_val=`expr "$@" || test $? -eq 1`
--  }
-+  } ;;
-+esac
- fi # as_fn_arith
- 
- 
-@@ -419,9 +429,9 @@ as_fn_error ()
-   as_status=$1; test $as_status -eq 0 && as_status=1
-   if test "$4"; then
-     as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
--    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-   fi
--  $as_echo "$as_me: error: $2" >&2
-+  printf "%s\n" "$as_me: error: $2" >&2
-   as_fn_exit $as_status
- } # as_fn_error
- 
-@@ -448,7 +458,7 @@ as_me=`$as_basename -- "$0" ||
- $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
- 	 X"$0" : 'X\(//\)$' \| \
- 	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
--$as_echo X/"$0" |
-+printf "%s\n" X/"$0" |
-     sed '/^.*\/\([^/][^/]*\)\/*$/{
- 	    s//\1/
- 	    q
-@@ -481,6 +491,8 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits
-     /[$]LINENO/=
-   ' <$as_myself |
-     sed '
-+      t clear
-+      :clear
-       s/[$]LINENO.*/&-/
-       t lineno
-       b
-@@ -492,7 +504,7 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits
-       s/-\n.*//
-     ' >$as_me.lineno &&
-   chmod +x "$as_me.lineno" ||
--    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
-+    { printf "%s\n" "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
- 
-   # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
-   # already done that, so ensure we don't try to do so again and fall
-@@ -506,6 +518,10 @@ as_cr_alnum=$as_cr_Letters$as_cr_digits
-   exit
- }
- 
-+
-+# Determine whether it's possible to make 'echo' print without a newline.
-+# These variables are no longer used directly by Autoconf, but are AC_SUBSTed
-+# for compatibility with existing Makefiles.
- ECHO_C= ECHO_N= ECHO_T=
- case `echo -n x` in #(((((
- -n*)
-@@ -519,6 +535,12 @@ case `echo -n x` in #(((((
-   ECHO_N='-n';;
- esac
- 
-+# For backward compatibility with old third-party macros, we provide
-+# the shell variables $as_echo and $as_echo_n.  New code should use
-+# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively.
-+as_echo='printf %s\n'
-+as_echo_n='printf %s'
-+
- rm -f conf$$ conf$$.exe conf$$.file
- if test -d conf$$.dir; then
-   rm -f conf$$.dir/conf$$.file
-@@ -530,9 +552,9 @@ if (echo >conf$$.file) 2>/dev/null; then
-   if ln -s conf$$.file conf$$ 2>/dev/null; then
-     as_ln_s='ln -s'
-     # ... but there are two gotchas:
--    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
--    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
--    # In both cases, we have to default to `cp -pR'.
-+    # 1) On MSYS, both 'ln -s file dir' and 'ln file dir' fail.
-+    # 2) DJGPP < 2.04 has no symlinks; 'ln -s' creates a wrapper executable.
-+    # In both cases, we have to default to 'cp -pR'.
-     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-       as_ln_s='cp -pR'
-   elif ln conf$$.file conf$$ 2>/dev/null; then
-@@ -557,10 +579,12 @@ as_test_x='test -x'
- as_executable_p=as_fn_executable_p
- 
- # Sed expression to map a string onto a valid CPP name.
--as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
-+as_sed_cpp="y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
-+as_tr_cpp="eval sed '$as_sed_cpp'" # deprecated
- 
- # Sed expression to map a string onto a valid variable name.
--as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
-+as_sed_sh="y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
-+as_tr_sh="eval sed '$as_sed_sh'" # deprecated
- 
- 
- test -n "$DJDIR" || exec 7<&0 </dev/null
-@@ -593,40 +617,36 @@ PACKAGE_URL='http://openjdk.java.net'
- 
- # Factoring default headers for most tests.
- ac_includes_default="\
--#include <stdio.h>
--#ifdef HAVE_SYS_TYPES_H
--# include <sys/types.h>
--#endif
--#ifdef HAVE_SYS_STAT_H
--# include <sys/stat.h>
-+#include <stddef.h>
-+#ifdef HAVE_STDIO_H
-+# include <stdio.h>
- #endif
--#ifdef STDC_HEADERS
-+#ifdef HAVE_STDLIB_H
- # include <stdlib.h>
--# include <stddef.h>
--#else
--# ifdef HAVE_STDLIB_H
--#  include <stdlib.h>
--# endif
- #endif
- #ifdef HAVE_STRING_H
--# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
--#  include <memory.h>
--# endif
- # include <string.h>
- #endif
--#ifdef HAVE_STRINGS_H
--# include <strings.h>
--#endif
- #ifdef HAVE_INTTYPES_H
- # include <inttypes.h>
- #endif
- #ifdef HAVE_STDINT_H
- # include <stdint.h>
- #endif
-+#ifdef HAVE_STRINGS_H
-+# include <strings.h>
-+#endif
-+#ifdef HAVE_SYS_TYPES_H
-+# include <sys/types.h>
-+#endif
-+#ifdef HAVE_SYS_STAT_H
-+# include <sys/stat.h>
-+#endif
- #ifdef HAVE_UNISTD_H
- # include <unistd.h>
- #endif"
- 
-+ac_header_cxx_list=
- ac_subst_vars='LTLIBOBJS
- LIBOBJS
- CCACHE
-@@ -924,6 +944,7 @@ OPENJDK_TARGET_CPU_LEGACY
- REQUIRED_OS_VERSION
- REQUIRED_OS_NAME
- COMPILE_TYPE
-+OPENJDK_TARGET_LIBC
- OPENJDK_TARGET_CPU_ENDIAN
- OPENJDK_TARGET_CPU_BITS
- OPENJDK_TARGET_CPU_ARCH
-@@ -931,6 +952,7 @@ OPENJDK_TARGET_CPU
- OPENJDK_TARGET_OS_ENV
- OPENJDK_TARGET_OS_API
- OPENJDK_TARGET_OS
-+OPENJDK_BUILD_LIBC
- OPENJDK_BUILD_CPU_ENDIAN
- OPENJDK_BUILD_CPU_BITS
- OPENJDK_BUILD_CPU_ARCH
-@@ -1021,6 +1043,7 @@ infodir
- docdir
- oldincludedir
- includedir
-+runstatedir
- localstatedir
- sharedstatedir
- sysconfdir
-@@ -1072,6 +1095,7 @@ with_milestone
- with_update_version
- with_user_release_suffix
- with_build_number
-+with_company_name
- with_vendor_name
- with_vendor_url
- with_vendor_bug_url
-@@ -1264,6 +1288,7 @@ datadir='${datarootdir}'
- sysconfdir='${prefix}/etc'
- sharedstatedir='${prefix}/com'
- localstatedir='${prefix}/var'
-+runstatedir='${localstatedir}/run'
- includedir='${prefix}/include'
- oldincludedir='/usr/include'
- docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
-@@ -1293,8 +1318,6 @@ do
-   *)    ac_optarg=yes ;;
-   esac
- 
--  # Accept the important Cygnus configure options, so we can diagnose typos.
--
-   case $ac_dashdash$ac_option in
-   --)
-     ac_dashdash=yes ;;
-@@ -1335,9 +1358,9 @@ do
-     ac_useropt=`expr "x$ac_option" : 'x-*disable-\(.*\)'`
-     # Reject names that are not valid shell variable names.
-     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
--      as_fn_error $? "invalid feature name: $ac_useropt"
-+      as_fn_error $? "invalid feature name: '$ac_useropt'"
-     ac_useropt_orig=$ac_useropt
--    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-+    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
-     case $ac_user_opts in
-       *"
- "enable_$ac_useropt"
-@@ -1361,9 +1384,9 @@ do
-     ac_useropt=`expr "x$ac_option" : 'x-*enable-\([^=]*\)'`
-     # Reject names that are not valid shell variable names.
-     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
--      as_fn_error $? "invalid feature name: $ac_useropt"
-+      as_fn_error $? "invalid feature name: '$ac_useropt'"
-     ac_useropt_orig=$ac_useropt
--    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-+    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
-     case $ac_user_opts in
-       *"
- "enable_$ac_useropt"
-@@ -1516,6 +1539,15 @@ do
-   | -silent | --silent | --silen | --sile | --sil)
-     silent=yes ;;
- 
-+  -runstatedir | --runstatedir | --runstatedi | --runstated \
-+  | --runstate | --runstat | --runsta | --runst | --runs \
-+  | --run | --ru | --r)
-+    ac_prev=runstatedir ;;
-+  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
-+  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
-+  | --run=* | --ru=* | --r=*)
-+    runstatedir=$ac_optarg ;;
-+
-   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
-     ac_prev=sbindir ;;
-   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
-@@ -1565,9 +1597,9 @@ do
-     ac_useropt=`expr "x$ac_option" : 'x-*with-\([^=]*\)'`
-     # Reject names that are not valid shell variable names.
-     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
--      as_fn_error $? "invalid package name: $ac_useropt"
-+      as_fn_error $? "invalid package name: '$ac_useropt'"
-     ac_useropt_orig=$ac_useropt
--    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-+    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
-     case $ac_user_opts in
-       *"
- "with_$ac_useropt"
-@@ -1581,9 +1613,9 @@ do
-     ac_useropt=`expr "x$ac_option" : 'x-*without-\(.*\)'`
-     # Reject names that are not valid shell variable names.
-     expr "x$ac_useropt" : ".*[^-+._$as_cr_alnum]" >/dev/null &&
--      as_fn_error $? "invalid package name: $ac_useropt"
-+      as_fn_error $? "invalid package name: '$ac_useropt'"
-     ac_useropt_orig=$ac_useropt
--    ac_useropt=`$as_echo "$ac_useropt" | sed 's/[-+.]/_/g'`
-+    ac_useropt=`printf "%s\n" "$ac_useropt" | sed 's/[-+.]/_/g'`
-     case $ac_user_opts in
-       *"
- "with_$ac_useropt"
-@@ -1611,8 +1643,8 @@ do
-   | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
-     x_libraries=$ac_optarg ;;
- 
--  -*) as_fn_error $? "unrecognized option: \`$ac_option'
--Try \`$0 --help' for more information"
-+  -*) as_fn_error $? "unrecognized option: '$ac_option'
-+Try '$0 --help' for more information"
-     ;;
- 
-   *=*)
-@@ -1620,16 +1652,16 @@ Try \`$0 --help' for more information"
-     # Reject names that are not valid shell variable names.
-     case $ac_envvar in #(
-       '' | [0-9]* | *[!_$as_cr_alnum]* )
--      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
-+      as_fn_error $? "invalid variable name: '$ac_envvar'" ;;
-     esac
-     eval $ac_envvar=\$ac_optarg
-     export $ac_envvar ;;
- 
-   *)
-     # FIXME: should be removed in autoconf 3.0.
--    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
-+    printf "%s\n" "$as_me: WARNING: you should use --build, --host, --target" >&2
-     expr "x$ac_option" : ".*[^-._$as_cr_alnum]" >/dev/null &&
--      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
-+      printf "%s\n" "$as_me: WARNING: invalid host type: $ac_option" >&2
-     : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
-     ;;
- 
-@@ -1645,7 +1677,7 @@ if test -n "$ac_unrecognized_opts"; then
-   case $enable_option_checking in
-     no) ;;
-     fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
--    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
-+    *)     printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
-   esac
- fi
- 
-@@ -1653,7 +1685,7 @@ fi
- for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
- 		datadir sysconfdir sharedstatedir localstatedir includedir \
- 		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
--		libdir localedir mandir
-+		libdir localedir mandir runstatedir
- do
-   eval ac_val=\$$ac_var
-   # Remove trailing slashes.
-@@ -1670,7 +1702,7 @@ do
-   as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
- done
- 
--# There might be people who depend on the old broken behavior: `$host'
-+# There might be people who depend on the old broken behavior: '$host'
- # used to hold the argument of --host etc.
- # FIXME: To remove some day.
- build=$build_alias
-@@ -1709,7 +1741,7 @@ $as_expr X"$as_myself" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
- 	 X"$as_myself" : 'X\(//\)[^/]' \| \
- 	 X"$as_myself" : 'X\(//\)$' \| \
- 	 X"$as_myself" : 'X\(/\)' \| . 2>/dev/null ||
--$as_echo X"$as_myself" |
-+printf "%s\n" X"$as_myself" |
-     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
- 	    s//\1/
- 	    q
-@@ -1738,7 +1770,7 @@ if test ! -r "$srcdir/$ac_unique_file"; then
-   test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
-   as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
- fi
--ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
-+ac_msg="sources are in $srcdir, but 'cd $srcdir' does not work"
- ac_abs_confdir=`(
- 	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
- 	pwd)`
-@@ -1766,7 +1798,7 @@ if test "$ac_init_help" = "long"; then
-   # Omit some internal or obsolete options to make the list less imposing.
-   # This message is too long to be a string in the A/UX 3.1 sh.
-   cat <<_ACEOF
--\`configure' configures OpenJDK jdk8 to adapt to many kinds of systems.
-+'configure' configures OpenJDK jdk8 to adapt to many kinds of systems.
- 
- Usage: $0 [OPTION]... [VAR=VALUE]...
- 
-@@ -1780,11 +1812,11 @@ Configuration:
-       --help=short        display options specific to this package
-       --help=recursive    display the short help of all the included packages
-   -V, --version           display version information and exit
--  -q, --quiet, --silent   do not print \`checking ...' messages
-+  -q, --quiet, --silent   do not print 'checking ...' messages
-       --cache-file=FILE   cache test results in FILE [disabled]
--  -C, --config-cache      alias for \`--cache-file=config.cache'
-+  -C, --config-cache      alias for '--cache-file=config.cache'
-   -n, --no-create         do not create output files
--      --srcdir=DIR        find the sources in DIR [configure dir or \`..']
-+      --srcdir=DIR        find the sources in DIR [configure dir or '..']
- 
- Installation directories:
-   --prefix=PREFIX         install architecture-independent files in PREFIX
-@@ -1792,10 +1824,10 @@ Installation directories:
-   --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
-                           [PREFIX]
- 
--By default, \`make install' will install all the files in
--\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
--an installation prefix other than \`$ac_default_prefix' using \`--prefix',
--for instance \`--prefix=\$HOME'.
-+By default, 'make install' will install all the files in
-+'$ac_default_prefix/bin', '$ac_default_prefix/lib' etc.  You can specify
-+an installation prefix other than '$ac_default_prefix' using '--prefix',
-+for instance '--prefix=\$HOME'.
- 
- For better control, use the options below.
- 
-@@ -1806,6 +1838,7 @@ Fine tuning of the installation directories:
-   --sysconfdir=DIR        read-only single-machine data [PREFIX/etc]
-   --sharedstatedir=DIR    modifiable architecture-independent data [PREFIX/com]
-   --localstatedir=DIR     modifiable single-machine data [PREFIX/var]
-+  --runstatedir=DIR       modifiable per-process data [LOCALSTATEDIR/run]
-   --libdir=DIR            object code libraries [EPREFIX/lib]
-   --includedir=DIR        C header files [PREFIX/include]
-   --oldincludedir=DIR     C header files for non-gcc [/usr/include]
-@@ -1908,6 +1941,7 @@ Optional Packages:
-                           Add a custom string to the version string if build
-                           number isn't set.[username_builddateb00]
-   --with-build-number     Set build number value for build [b00]
-+  --with-company-name     Set company name.
-   --with-vendor-name      Set vendor name. Among others, used to set the
-                           'java.vendor' and 'java.vm.vendor' system
-                           properties. [not specified]
-@@ -2114,7 +2148,7 @@ Some influential environment variables:
-   LIBFFI_LIBS linker flags for LIBFFI, overriding pkg-config
-   CCACHE      Override default value for CCACHE
- 
--Use these variables to override the choices made by `configure' or to help
-+Use these variables to override the choices made by 'configure' or to help
- it to find libraries and programs with nonstandard names/locations.
- 
- Report bugs to <build-dev@openjdk.java.net>.
-@@ -2134,9 +2168,9 @@ if test "$ac_init_help" = "recursive"; then
- case "$ac_dir" in
- .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
- *)
--  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
-+  ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'`
-   # A ".." for each directory in $ac_dir_suffix.
--  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-+  ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-   case $ac_top_builddir_sub in
-   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
-   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
-@@ -2164,7 +2198,8 @@ esac
- ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
- 
-     cd "$ac_dir" || { ac_status=$?; continue; }
--    # Check for guested configure.
-+    # Check for configure.gnu first; this name is used for a wrapper for
-+    # Metaconfig's "Configure" on case-insensitive file systems.
-     if test -f "$ac_srcdir/configure.gnu"; then
-       echo &&
-       $SHELL "$ac_srcdir/configure.gnu" --help=recursive
-@@ -2172,7 +2207,7 @@ ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
-       echo &&
-       $SHELL "$ac_srcdir/configure" --help=recursive
-     else
--      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
-+      printf "%s\n" "$as_me: WARNING: no configuration information is in $ac_dir" >&2
-     fi || ac_status=$?
-     cd "$ac_pwd" || { ac_status=$?; break; }
-   done
-@@ -2182,9 +2217,9 @@ test -n "$ac_init_help" && exit $ac_status
- if $ac_init_version; then
-   cat <<\_ACEOF
- OpenJDK configure jdk8
--generated by GNU Autoconf 2.69
-+generated by GNU Autoconf 2.72
- 
--Copyright (C) 2012 Free Software Foundation, Inc.
-+Copyright (C) 2023 Free Software Foundation, Inc.
- This configure script is free software; the Free Software Foundation
- gives unlimited permission to copy, distribute and modify it.
- _ACEOF
-@@ -2201,14 +2236,14 @@ fi
- ac_fn_c_try_compile ()
- {
-   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
--  rm -f conftest.$ac_objext
-+  rm -f conftest.$ac_objext conftest.beam
-   if { { ac_try="$ac_compile"
- case "(($ac_try" in
-   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_compile") 2>conftest.err
-   ac_status=$?
-   if test -s conftest.err; then
-@@ -2216,17 +2251,19 @@ $as_echo "$ac_try_echo"; } >&5
-     cat conftest.er1 >&5
-     mv -f conftest.er1 conftest.err
-   fi
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; } && {
- 	 test -z "$ac_c_werror_flag" ||
- 	 test ! -s conftest.err
--       } && test -s conftest.$ac_objext; then :
-+       } && test -s conftest.$ac_objext
-+then :
-   ac_retval=0
--else
--  $as_echo "$as_me: failed program was:" >&5
-+else case e in #(
-+  e) printf "%s\n" "$as_me: failed program was:" >&5
- sed 's/^/| /' conftest.$ac_ext >&5
- 
--	ac_retval=1
-+	ac_retval=1 ;;
-+esac
- fi
-   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-   as_fn_set_status $ac_retval
-@@ -2239,14 +2276,14 @@ fi
- ac_fn_cxx_try_compile ()
- {
-   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
--  rm -f conftest.$ac_objext
-+  rm -f conftest.$ac_objext conftest.beam
-   if { { ac_try="$ac_compile"
- case "(($ac_try" in
-   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_compile") 2>conftest.err
-   ac_status=$?
-   if test -s conftest.err; then
-@@ -2254,17 +2291,19 @@ $as_echo "$ac_try_echo"; } >&5
-     cat conftest.er1 >&5
-     mv -f conftest.er1 conftest.err
-   fi
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; } && {
- 	 test -z "$ac_cxx_werror_flag" ||
- 	 test ! -s conftest.err
--       } && test -s conftest.$ac_objext; then :
-+       } && test -s conftest.$ac_objext
-+then :
-   ac_retval=0
--else
--  $as_echo "$as_me: failed program was:" >&5
-+else case e in #(
-+  e) printf "%s\n" "$as_me: failed program was:" >&5
- sed 's/^/| /' conftest.$ac_ext >&5
- 
--	ac_retval=1
-+	ac_retval=1 ;;
-+esac
- fi
-   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-   as_fn_set_status $ac_retval
-@@ -2283,7 +2322,7 @@ case "(($ac_try" in
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
-   ac_status=$?
-   if test -s conftest.err; then
-@@ -2291,17 +2330,19 @@ $as_echo "$ac_try_echo"; } >&5
-     cat conftest.er1 >&5
-     mv -f conftest.er1 conftest.err
-   fi
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; } > conftest.i && {
- 	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
- 	 test ! -s conftest.err
--       }; then :
-+       }
-+then :
-   ac_retval=0
--else
--  $as_echo "$as_me: failed program was:" >&5
-+else case e in #(
-+  e) printf "%s\n" "$as_me: failed program was:" >&5
- sed 's/^/| /' conftest.$ac_ext >&5
- 
--    ac_retval=1
-+    ac_retval=1 ;;
-+esac
- fi
-   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-   as_fn_set_status $ac_retval
-@@ -2320,7 +2361,7 @@ case "(($ac_try" in
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
-   ac_status=$?
-   if test -s conftest.err; then
-@@ -2328,17 +2369,19 @@ $as_echo "$ac_try_echo"; } >&5
-     cat conftest.er1 >&5
-     mv -f conftest.er1 conftest.err
-   fi
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; } > conftest.i && {
- 	 test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
- 	 test ! -s conftest.err
--       }; then :
-+       }
-+then :
-   ac_retval=0
--else
--  $as_echo "$as_me: failed program was:" >&5
-+else case e in #(
-+  e) printf "%s\n" "$as_me: failed program was:" >&5
- sed 's/^/| /' conftest.$ac_ext >&5
- 
--    ac_retval=1
-+    ac_retval=1 ;;
-+esac
- fi
-   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-   as_fn_set_status $ac_retval
-@@ -2351,14 +2394,14 @@ fi
- ac_fn_objc_try_compile ()
- {
-   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
--  rm -f conftest.$ac_objext
-+  rm -f conftest.$ac_objext conftest.beam
-   if { { ac_try="$ac_compile"
- case "(($ac_try" in
-   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_compile") 2>conftest.err
-   ac_status=$?
-   if test -s conftest.err; then
-@@ -2366,118 +2409,64 @@ $as_echo "$ac_try_echo"; } >&5
-     cat conftest.er1 >&5
-     mv -f conftest.er1 conftest.err
-   fi
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; } && {
- 	 test -z "$ac_objc_werror_flag" ||
- 	 test ! -s conftest.err
--       } && test -s conftest.$ac_objext; then :
-+       } && test -s conftest.$ac_objext
-+then :
-   ac_retval=0
--else
--  $as_echo "$as_me: failed program was:" >&5
-+else case e in #(
-+  e) printf "%s\n" "$as_me: failed program was:" >&5
- sed 's/^/| /' conftest.$ac_ext >&5
- 
--	ac_retval=1
-+	ac_retval=1 ;;
-+esac
- fi
-   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-   as_fn_set_status $ac_retval
- 
- } # ac_fn_objc_try_compile
- 
--# ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
-+# ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
- # ---------------------------------------------------------
--# Tests whether HEADER exists, giving a warning if it cannot be compiled using
--# the include files in INCLUDES and setting the cache variable VAR
--# accordingly.
--ac_fn_cxx_check_header_mongrel ()
-+# Tests whether HEADER exists and can be compiled using the include files in
-+# INCLUDES, setting the cache variable VAR accordingly.
-+ac_fn_cxx_check_header_compile ()
- {
-   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
--  if eval \${$3+:} false; then :
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
--$as_echo_n "checking for $2... " >&6; }
--if eval \${$3+:} false; then :
--  $as_echo_n "(cached) " >&6
--fi
--eval ac_res=\$$3
--	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
--$as_echo "$ac_res" >&6; }
--else
--  # Is the header compilable?
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
--$as_echo_n "checking $2 usability... " >&6; }
--cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
-+printf %s "checking for $2... " >&6; }
-+if eval test \${$3+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- $4
- #include <$2>
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
--  ac_header_compiler=yes
--else
--  ac_header_compiler=no
--fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
--$as_echo "$ac_header_compiler" >&6; }
--
--# Is the header present?
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
--$as_echo_n "checking $2 presence... " >&6; }
--cat confdefs.h - <<_ACEOF >conftest.$ac_ext
--/* end confdefs.h.  */
--#include <$2>
--_ACEOF
--if ac_fn_cxx_try_cpp "$LINENO"; then :
--  ac_header_preproc=yes
--else
--  ac_header_preproc=no
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-+  eval "$3=yes"
-+else case e in #(
-+  e) eval "$3=no" ;;
-+esac
- fi
--rm -f conftest.err conftest.i conftest.$ac_ext
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
--$as_echo "$ac_header_preproc" >&6; }
--
--# So?  What about this header?
--case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
--  yes:no: )
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
--$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
--$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
--    ;;
--  no:yes:* )
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
--$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
--$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
--$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
--$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
--$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
--( $as_echo "## ----------------------------------------- ##
--## Report this to build-dev@openjdk.java.net ##
--## ----------------------------------------- ##"
--     ) | sed "s/^/$as_me: WARNING:     /" >&2
--    ;;
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
- esac
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
--$as_echo_n "checking for $2... " >&6; }
--if eval \${$3+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  eval "$3=\$ac_header_compiler"
- fi
- eval ac_res=\$$3
--	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
--$as_echo "$ac_res" >&6; }
--fi
-+	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-+printf "%s\n" "$ac_res" >&6; }
-   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
- 
--} # ac_fn_cxx_check_header_mongrel
-+} # ac_fn_cxx_check_header_compile
- 
- # ac_fn_cxx_try_run LINENO
- # ------------------------
--# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
--# that executables *can* be run.
-+# Try to run conftest.$ac_ext, and return whether this succeeded. Assumes that
-+# executables *can* be run.
- ac_fn_cxx_try_run ()
- {
-   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-@@ -2487,28 +2476,30 @@ case "(($ac_try" in
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_link") 2>&5
-   ac_status=$?
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
-   { { case "(($ac_try" in
-   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_try") 2>&5
-   ac_status=$?
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
--  test $ac_status = 0; }; }; then :
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  test $ac_status = 0; }; }
-+then :
-   ac_retval=0
--else
--  $as_echo "$as_me: program exited with status $ac_status" >&5
--       $as_echo "$as_me: failed program was:" >&5
-+else case e in #(
-+  e) printf "%s\n" "$as_me: program exited with status $ac_status" >&5
-+       printf "%s\n" "$as_me: failed program was:" >&5
- sed 's/^/| /' conftest.$ac_ext >&5
- 
--       ac_retval=$ac_status
-+       ac_retval=$ac_status ;;
-+esac
- fi
-   rm -rf conftest.dSYM conftest_ipa8_conftest.oo
-   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-@@ -2516,37 +2507,6 @@ fi
- 
- } # ac_fn_cxx_try_run
- 
--# ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
--# ---------------------------------------------------------
--# Tests whether HEADER exists and can be compiled using the include files in
--# INCLUDES, setting the cache variable VAR accordingly.
--ac_fn_cxx_check_header_compile ()
--{
--  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
--$as_echo_n "checking for $2... " >&6; }
--if eval \${$3+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
--/* end confdefs.h.  */
--$4
--#include <$2>
--_ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
--  eval "$3=yes"
--else
--  eval "$3=no"
--fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
--fi
--eval ac_res=\$$3
--	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
--$as_echo "$ac_res" >&6; }
--  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
--
--} # ac_fn_cxx_check_header_compile
--
- # ac_fn_cxx_compute_int LINENO EXPR VAR INCLUDES
- # ----------------------------------------------
- # Tries to find the compile-time value of EXPR in a program that includes
-@@ -2561,7 +2521,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- $4
- int
--main ()
-+main (void)
- {
- static int test_array [1 - 2 * !(($2) >= 0)];
- test_array [0] = 0;
-@@ -2571,14 +2531,15 @@ return test_array [0];
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-   ac_lo=0 ac_mid=0
-   while :; do
-     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- $4
- int
--main ()
-+main (void)
- {
- static int test_array [1 - 2 * !(($2) <= $ac_mid)];
- test_array [0] = 0;
-@@ -2588,24 +2549,26 @@ return test_array [0];
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-   ac_hi=$ac_mid; break
--else
--  as_fn_arith $ac_mid + 1 && ac_lo=$as_val
-+else case e in #(
-+  e) as_fn_arith $ac_mid + 1 && ac_lo=$as_val
- 			if test $ac_lo -le $ac_mid; then
- 			  ac_lo= ac_hi=
- 			  break
- 			fi
--			as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val
-+			as_fn_arith 2 '*' $ac_mid + 1 && ac_mid=$as_val ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   done
--else
--  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+else case e in #(
-+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- $4
- int
--main ()
-+main (void)
- {
- static int test_array [1 - 2 * !(($2) < 0)];
- test_array [0] = 0;
-@@ -2615,14 +2578,15 @@ return test_array [0];
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-   ac_hi=-1 ac_mid=-1
-   while :; do
-     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- $4
- int
--main ()
-+main (void)
- {
- static int test_array [1 - 2 * !(($2) >= $ac_mid)];
- test_array [0] = 0;
-@@ -2632,24 +2596,28 @@ return test_array [0];
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-   ac_lo=$ac_mid; break
--else
--  as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
-+else case e in #(
-+  e) as_fn_arith '(' $ac_mid ')' - 1 && ac_hi=$as_val
- 			if test $ac_mid -le $ac_hi; then
- 			  ac_lo= ac_hi=
- 			  break
- 			fi
--			as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val
-+			as_fn_arith 2 '*' $ac_mid && ac_mid=$as_val ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   done
--else
--  ac_lo= ac_hi=
-+else case e in #(
-+  e) ac_lo= ac_hi= ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
- # Binary search between lo and hi bounds.
- while test "x$ac_lo" != "x$ac_hi"; do
-   as_fn_arith '(' $ac_hi - $ac_lo ')' / 2 + $ac_lo && ac_mid=$as_val
-@@ -2657,7 +2625,7 @@ while test "x$ac_lo" != "x$ac_hi"; do
- /* end confdefs.h.  */
- $4
- int
--main ()
-+main (void)
- {
- static int test_array [1 - 2 * !(($2) <= $ac_mid)];
- test_array [0] = 0;
-@@ -2667,12 +2635,14 @@ return test_array [0];
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-   ac_hi=$ac_mid
--else
--  as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val
-+else case e in #(
-+  e) as_fn_arith '(' $ac_mid ')' + 1 && ac_lo=$as_val ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
- done
- case $ac_lo in #((
- ?*) eval "$3=\$ac_lo"; ac_retval=0 ;;
-@@ -2682,12 +2652,12 @@ esac
-     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- $4
--static long int longval () { return $2; }
--static unsigned long int ulongval () { return $2; }
-+static long int longval (void) { return $2; }
-+static unsigned long int ulongval (void) { return $2; }
- #include <stdio.h>
- #include <stdlib.h>
- int
--main ()
-+main (void)
- {
- 
-   FILE *f = fopen ("conftest.val", "w");
-@@ -2715,10 +2685,12 @@ main ()
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_run "$LINENO"; then :
-+if ac_fn_cxx_try_run "$LINENO"
-+then :
-   echo >>conftest.val; read $3 <conftest.val; ac_retval=0
--else
--  ac_retval=1
-+else case e in #(
-+  e) ac_retval=1 ;;
-+esac
- fi
- rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
-   conftest.$ac_objext conftest.beam conftest.$ac_ext
-@@ -2736,14 +2708,14 @@ rm -f conftest.val
- ac_fn_cxx_try_link ()
- {
-   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
--  rm -f conftest.$ac_objext conftest$ac_exeext
-+  rm -f conftest.$ac_objext conftest.beam conftest$ac_exeext
-   if { { ac_try="$ac_link"
- case "(($ac_try" in
-   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_link") 2>conftest.err
-   ac_status=$?
-   if test -s conftest.err; then
-@@ -2751,20 +2723,22 @@ $as_echo "$ac_try_echo"; } >&5
-     cat conftest.er1 >&5
-     mv -f conftest.er1 conftest.err
-   fi
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; } && {
- 	 test -z "$ac_cxx_werror_flag" ||
- 	 test ! -s conftest.err
-        } && test -s conftest$ac_exeext && {
- 	 test "$cross_compiling" = yes ||
- 	 test -x conftest$ac_exeext
--       }; then :
-+       }
-+then :
-   ac_retval=0
--else
--  $as_echo "$as_me: failed program was:" >&5
-+else case e in #(
-+  e) printf "%s\n" "$as_me: failed program was:" >&5
- sed 's/^/| /' conftest.$ac_ext >&5
- 
--	ac_retval=1
-+	ac_retval=1 ;;
-+esac
- fi
-   # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
-   # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
-@@ -2782,28 +2756,22 @@ fi
- ac_fn_cxx_check_func ()
- {
-   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
--$as_echo_n "checking for $2... " >&6; }
--if eval \${$3+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
-+printf %s "checking for $2... " >&6; }
-+if eval test \${$3+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- /* Define $2 to an innocuous variant, in case <limits.h> declares $2.
-    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
- #define $2 innocuous_$2
- 
- /* System header to define __stub macros and hopefully few prototypes,
--    which can conflict with char $2 (); below.
--    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
--    <limits.h> exists even on freestanding compilers.  */
--
--#ifdef __STDC__
--# include <limits.h>
--#else
--# include <assert.h>
--#endif
-+   which can conflict with char $2 (void); below.  */
- 
-+#include <limits.h>
- #undef $2
- 
- /* Override any GCC internal prototype to avoid an error.
-@@ -2812,7 +2780,7 @@ else
- #ifdef __cplusplus
- extern "C"
- #endif
--char $2 ();
-+char $2 (void);
- /* The GNU C library defines this for functions which it implements
-     to always fail with ENOSYS.  Some functions are actually named
-     something starting with __ and the normal name is an alias.  */
-@@ -2821,24 +2789,27 @@ choke me
- #endif
- 
- int
--main ()
-+main (void)
- {
- return $2 ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   eval "$3=yes"
--else
--  eval "$3=no"
-+else case e in #(
-+  e) eval "$3=no" ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
--    conftest$ac_exeext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-+    conftest$ac_exeext conftest.$ac_ext ;;
-+esac
- fi
- eval ac_res=\$$3
--	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
--$as_echo "$ac_res" >&6; }
-+	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-+printf "%s\n" "$ac_res" >&6; }
-   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
- 
- } # ac_fn_cxx_check_func
-@@ -2850,37 +2821,61 @@ $as_echo "$ac_res" >&6; }
- ac_fn_c_check_header_compile ()
- {
-   as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
--$as_echo_n "checking for $2... " >&6; }
--if eval \${$3+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
-+printf %s "checking for $2... " >&6; }
-+if eval test \${$3+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- $4
- #include <$2>
- _ACEOF
--if ac_fn_c_try_compile "$LINENO"; then :
-+if ac_fn_c_try_compile "$LINENO"
-+then :
-   eval "$3=yes"
--else
--  eval "$3=no"
-+else case e in #(
-+  e) eval "$3=no" ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
-+esac
- fi
- eval ac_res=\$$3
--	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
--$as_echo "$ac_res" >&6; }
-+	       { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-+printf "%s\n" "$ac_res" >&6; }
-   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
- 
- } # ac_fn_c_check_header_compile
-+ac_configure_args_raw=
-+for ac_arg
-+do
-+  case $ac_arg in
-+  *\'*)
-+    ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
-+  esac
-+  as_fn_append ac_configure_args_raw " '$ac_arg'"
-+done
-+
-+case $ac_configure_args_raw in
-+  *$as_nl*)
-+    ac_safe_unquote= ;;
-+  *)
-+    ac_unsafe_z='|&;<>()$`\\"*?[ ''	' # This string ends in space, tab.
-+    ac_unsafe_a="$ac_unsafe_z#~"
-+    ac_safe_unquote="s/ '\\([^$ac_unsafe_a][^$ac_unsafe_z]*\\)'/ \\1/g"
-+    ac_configure_args_raw=`      printf "%s\n" "$ac_configure_args_raw" | sed "$ac_safe_unquote"`;;
-+esac
-+
- cat >config.log <<_ACEOF
- This file contains any messages produced by compilers while
- running configure, to aid debugging if configure makes a mistake.
- 
- It was created by OpenJDK $as_me jdk8, which was
--generated by GNU Autoconf 2.69.  Invocation command line was
-+generated by GNU Autoconf 2.72.  Invocation command line was
- 
--  $ $0 $@
-+  $ $0$ac_configure_args_raw
- 
- _ACEOF
- exec 5>>config.log
-@@ -2913,8 +2908,12 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
--    $as_echo "PATH: $as_dir"
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-+    printf "%s\n" "PATH: $as_dir"
-   done
- IFS=$as_save_IFS
- 
-@@ -2949,7 +2948,7 @@ do
-     | -silent | --silent | --silen | --sile | --sil)
-       continue ;;
-     *\'*)
--      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
-+      ac_arg=`printf "%s\n" "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
-     esac
-     case $ac_pass in
-     1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
-@@ -2984,11 +2983,13 @@ done
- # WARNING: Use '\'' to represent an apostrophe within the trap.
- # WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
- trap 'exit_status=$?
-+  # Sanitize IFS.
-+  IFS=" ""	$as_nl"
-   # Save into config.log some information that might help in debugging.
-   {
-     echo
- 
--    $as_echo "## ---------------- ##
-+    printf "%s\n" "## ---------------- ##
- ## Cache variables. ##
- ## ---------------- ##"
-     echo
-@@ -2999,8 +3000,8 @@ trap 'exit_status=$?
-     case $ac_val in #(
-     *${as_nl}*)
-       case $ac_var in #(
--      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
--$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-+      *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-+printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-       esac
-       case $ac_var in #(
-       _ | IFS | as_nl) ;; #(
-@@ -3024,7 +3025,7 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
- )
-     echo
- 
--    $as_echo "## ----------------- ##
-+    printf "%s\n" "## ----------------- ##
- ## Output variables. ##
- ## ----------------- ##"
-     echo
-@@ -3032,14 +3033,14 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-     do
-       eval ac_val=\$$ac_var
-       case $ac_val in
--      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
-+      *\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
-       esac
--      $as_echo "$ac_var='\''$ac_val'\''"
-+      printf "%s\n" "$ac_var='\''$ac_val'\''"
-     done | sort
-     echo
- 
-     if test -n "$ac_subst_files"; then
--      $as_echo "## ------------------- ##
-+      printf "%s\n" "## ------------------- ##
- ## File substitutions. ##
- ## ------------------- ##"
-       echo
-@@ -3047,15 +3048,15 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-       do
- 	eval ac_val=\$$ac_var
- 	case $ac_val in
--	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
-+	*\'\''*) ac_val=`printf "%s\n" "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
- 	esac
--	$as_echo "$ac_var='\''$ac_val'\''"
-+	printf "%s\n" "$ac_var='\''$ac_val'\''"
-       done | sort
-       echo
-     fi
- 
-     if test -s confdefs.h; then
--      $as_echo "## ----------- ##
-+      printf "%s\n" "## ----------- ##
- ## confdefs.h. ##
- ## ----------- ##"
-       echo
-@@ -3063,8 +3064,8 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-       echo
-     fi
-     test "$ac_signal" != 0 &&
--      $as_echo "$as_me: caught signal $ac_signal"
--    $as_echo "$as_me: exit $exit_status"
-+      printf "%s\n" "$as_me: caught signal $ac_signal"
-+    printf "%s\n" "$as_me: exit $exit_status"
-   } >&5
-   rm -f core *.core core.conftest.* &&
-     rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
-@@ -3078,65 +3079,50 @@ ac_signal=0
- # confdefs.h avoids OS command line length limits that DEFS can exceed.
- rm -f -r conftest* confdefs.h
- 
--$as_echo "/* confdefs.h */" > confdefs.h
-+printf "%s\n" "/* confdefs.h */" > confdefs.h
- 
- # Predefined preprocessor variables.
- 
--cat >>confdefs.h <<_ACEOF
--#define PACKAGE_NAME "$PACKAGE_NAME"
--_ACEOF
-+printf "%s\n" "#define PACKAGE_NAME \"$PACKAGE_NAME\"" >>confdefs.h
- 
--cat >>confdefs.h <<_ACEOF
--#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
--_ACEOF
-+printf "%s\n" "#define PACKAGE_TARNAME \"$PACKAGE_TARNAME\"" >>confdefs.h
- 
--cat >>confdefs.h <<_ACEOF
--#define PACKAGE_VERSION "$PACKAGE_VERSION"
--_ACEOF
-+printf "%s\n" "#define PACKAGE_VERSION \"$PACKAGE_VERSION\"" >>confdefs.h
- 
--cat >>confdefs.h <<_ACEOF
--#define PACKAGE_STRING "$PACKAGE_STRING"
--_ACEOF
-+printf "%s\n" "#define PACKAGE_STRING \"$PACKAGE_STRING\"" >>confdefs.h
- 
--cat >>confdefs.h <<_ACEOF
--#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
--_ACEOF
-+printf "%s\n" "#define PACKAGE_BUGREPORT \"$PACKAGE_BUGREPORT\"" >>confdefs.h
- 
--cat >>confdefs.h <<_ACEOF
--#define PACKAGE_URL "$PACKAGE_URL"
--_ACEOF
-+printf "%s\n" "#define PACKAGE_URL \"$PACKAGE_URL\"" >>confdefs.h
- 
- 
- # Let the site file select an alternate cache file if it wants to.
- # Prefer an explicitly selected file to automatically selected ones.
--ac_site_file1=NONE
--ac_site_file2=NONE
- if test -n "$CONFIG_SITE"; then
--  # We do not want a PATH search for config.site.
--  case $CONFIG_SITE in #((
--    -*)  ac_site_file1=./$CONFIG_SITE;;
--    */*) ac_site_file1=$CONFIG_SITE;;
--    *)   ac_site_file1=./$CONFIG_SITE;;
--  esac
-+  ac_site_files="$CONFIG_SITE"
- elif test "x$prefix" != xNONE; then
--  ac_site_file1=$prefix/share/config.site
--  ac_site_file2=$prefix/etc/config.site
-+  ac_site_files="$prefix/share/config.site $prefix/etc/config.site"
- else
--  ac_site_file1=$ac_default_prefix/share/config.site
--  ac_site_file2=$ac_default_prefix/etc/config.site
-+  ac_site_files="$ac_default_prefix/share/config.site $ac_default_prefix/etc/config.site"
- fi
--for ac_site_file in "$ac_site_file1" "$ac_site_file2"
-+
-+for ac_site_file in $ac_site_files
- do
--  test "x$ac_site_file" = xNONE && continue
--  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
--$as_echo "$as_me: loading site script $ac_site_file" >&6;}
-+  case $ac_site_file in #(
-+  */*) :
-+     ;; #(
-+  *) :
-+    ac_site_file=./$ac_site_file ;;
-+esac
-+  if test -f "$ac_site_file" && test -r "$ac_site_file"; then
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
-+printf "%s\n" "$as_me: loading site script $ac_site_file" >&6;}
-     sed 's/^/| /' "$ac_site_file" >&5
-     . "$ac_site_file" \
--      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
--$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-+      || { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
- as_fn_error $? "failed to load site script $ac_site_file
--See \`config.log' for more details" "$LINENO" 5; }
-+See 'config.log' for more details" "$LINENO" 5; }
-   fi
- done
- 
-@@ -3144,19 +3130,668 @@ if test -r "$cache_file"; then
-   # Some versions of bash will fail to source /dev/null (special files
-   # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
-   if test /dev/null != "$cache_file" && test -f "$cache_file"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
--$as_echo "$as_me: loading cache $cache_file" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
-+printf "%s\n" "$as_me: loading cache $cache_file" >&6;}
-     case $cache_file in
-       [\\/]* | ?:[\\/]* ) . "$cache_file";;
-       *)                      . "./$cache_file";;
-     esac
-   fi
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
--$as_echo "$as_me: creating cache $cache_file" >&6;}
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
-+printf "%s\n" "$as_me: creating cache $cache_file" >&6;}
-   >$cache_file
- fi
- 
-+# Test code for whether the C compiler supports C89 (global declarations)
-+ac_c_conftest_c89_globals='
-+/* Does the compiler advertise C89 conformance?
-+   Do not test the value of __STDC__, because some compilers set it to 0
-+   while being otherwise adequately conformant. */
-+#if !defined __STDC__
-+# error "Compiler does not advertise C89 conformance"
-+#endif
-+
-+#include <stddef.h>
-+#include <stdarg.h>
-+struct stat;
-+/* Most of the following tests are stolen from RCS 5.7 src/conf.sh.  */
-+struct buf { int x; };
-+struct buf * (*rcsopen) (struct buf *, struct stat *, int);
-+static char *e (char **p, int i)
-+{
-+  return p[i];
-+}
-+static char *f (char * (*g) (char **, int), char **p, ...)
-+{
-+  char *s;
-+  va_list v;
-+  va_start (v,p);
-+  s = g (p, va_arg (v,int));
-+  va_end (v);
-+  return s;
-+}
-+
-+/* C89 style stringification. */
-+#define noexpand_stringify(a) #a
-+const char *stringified = noexpand_stringify(arbitrary+token=sequence);
-+
-+/* C89 style token pasting.  Exercises some of the corner cases that
-+   e.g. old MSVC gets wrong, but not very hard. */
-+#define noexpand_concat(a,b) a##b
-+#define expand_concat(a,b) noexpand_concat(a,b)
-+extern int vA;
-+extern int vbee;
-+#define aye A
-+#define bee B
-+int *pvA = &expand_concat(v,aye);
-+int *pvbee = &noexpand_concat(v,bee);
-+
-+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
-+   function prototypes and stuff, but not \xHH hex character constants.
-+   These do not provoke an error unfortunately, instead are silently treated
-+   as an "x".  The following induces an error, until -std is added to get
-+   proper ANSI mode.  Curiously \x00 != x always comes out true, for an
-+   array size at least.  It is necessary to write \x00 == 0 to get something
-+   that is true only with -std.  */
-+int osf4_cc_array ['\''\x00'\'' == 0 ? 1 : -1];
-+
-+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
-+   inside strings and character constants.  */
-+#define FOO(x) '\''x'\''
-+int xlc6_cc_array[FOO(a) == '\''x'\'' ? 1 : -1];
-+
-+int test (int i, double x);
-+struct s1 {int (*f) (int a);};
-+struct s2 {int (*f) (double a);};
-+int pairnames (int, char **, int *(*)(struct buf *, struct stat *, int),
-+               int, int);'
-+
-+# Test code for whether the C compiler supports C89 (body of main).
-+ac_c_conftest_c89_main='
-+ok |= (argc == 0 || f (e, argv, 0) != argv[0] || f (e, argv, 1) != argv[1]);
-+'
-+
-+# Test code for whether the C compiler supports C99 (global declarations)
-+ac_c_conftest_c99_globals='
-+/* Does the compiler advertise C99 conformance? */
-+#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 199901L
-+# error "Compiler does not advertise C99 conformance"
-+#endif
-+
-+// See if C++-style comments work.
-+
-+#include <stdbool.h>
-+extern int puts (const char *);
-+extern int printf (const char *, ...);
-+extern int dprintf (int, const char *, ...);
-+extern void *malloc (size_t);
-+extern void free (void *);
-+
-+// Check varargs macros.  These examples are taken from C99 6.10.3.5.
-+// dprintf is used instead of fprintf to avoid needing to declare
-+// FILE and stderr.
-+#define debug(...) dprintf (2, __VA_ARGS__)
-+#define showlist(...) puts (#__VA_ARGS__)
-+#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
-+static void
-+test_varargs_macros (void)
-+{
-+  int x = 1234;
-+  int y = 5678;
-+  debug ("Flag");
-+  debug ("X = %d\n", x);
-+  showlist (The first, second, and third items.);
-+  report (x>y, "x is %d but y is %d", x, y);
-+}
-+
-+// Check long long types.
-+#define BIG64 18446744073709551615ull
-+#define BIG32 4294967295ul
-+#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
-+#if !BIG_OK
-+  #error "your preprocessor is broken"
-+#endif
-+#if BIG_OK
-+#else
-+  #error "your preprocessor is broken"
-+#endif
-+static long long int bignum = -9223372036854775807LL;
-+static unsigned long long int ubignum = BIG64;
-+
-+struct incomplete_array
-+{
-+  int datasize;
-+  double data[];
-+};
-+
-+struct named_init {
-+  int number;
-+  const wchar_t *name;
-+  double average;
-+};
-+
-+typedef const char *ccp;
-+
-+static inline int
-+test_restrict (ccp restrict text)
-+{
-+  // Iterate through items via the restricted pointer.
-+  // Also check for declarations in for loops.
-+  for (unsigned int i = 0; *(text+i) != '\''\0'\''; ++i)
-+    continue;
-+  return 0;
-+}
-+
-+// Check varargs and va_copy.
-+static bool
-+test_varargs (const char *format, ...)
-+{
-+  va_list args;
-+  va_start (args, format);
-+  va_list args_copy;
-+  va_copy (args_copy, args);
-+
-+  const char *str = "";
-+  int number = 0;
-+  float fnumber = 0;
-+
-+  while (*format)
-+    {
-+      switch (*format++)
-+	{
-+	case '\''s'\'': // string
-+	  str = va_arg (args_copy, const char *);
-+	  break;
-+	case '\''d'\'': // int
-+	  number = va_arg (args_copy, int);
-+	  break;
-+	case '\''f'\'': // float
-+	  fnumber = va_arg (args_copy, double);
-+	  break;
-+	default:
-+	  break;
-+	}
-+    }
-+  va_end (args_copy);
-+  va_end (args);
-+
-+  return *str && number && fnumber;
-+}
-+'
-+
-+# Test code for whether the C compiler supports C99 (body of main).
-+ac_c_conftest_c99_main='
-+  // Check bool.
-+  _Bool success = false;
-+  success |= (argc != 0);
-+
-+  // Check restrict.
-+  if (test_restrict ("String literal") == 0)
-+    success = true;
-+  char *restrict newvar = "Another string";
-+
-+  // Check varargs.
-+  success &= test_varargs ("s, d'\'' f .", "string", 65, 34.234);
-+  test_varargs_macros ();
-+
-+  // Check flexible array members.
-+  struct incomplete_array *ia =
-+    malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
-+  ia->datasize = 10;
-+  for (int i = 0; i < ia->datasize; ++i)
-+    ia->data[i] = i * 1.234;
-+  // Work around memory leak warnings.
-+  free (ia);
-+
-+  // Check named initializers.
-+  struct named_init ni = {
-+    .number = 34,
-+    .name = L"Test wide string",
-+    .average = 543.34343,
-+  };
-+
-+  ni.number = 58;
-+
-+  int dynamic_array[ni.number];
-+  dynamic_array[0] = argv[0][0];
-+  dynamic_array[ni.number - 1] = 543;
-+
-+  // work around unused variable warnings
-+  ok |= (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == '\''x'\''
-+	 || dynamic_array[ni.number - 1] != 543);
-+'
-+
-+# Test code for whether the C compiler supports C11 (global declarations)
-+ac_c_conftest_c11_globals='
-+/* Does the compiler advertise C11 conformance? */
-+#if !defined __STDC_VERSION__ || __STDC_VERSION__ < 201112L
-+# error "Compiler does not advertise C11 conformance"
-+#endif
-+
-+// Check _Alignas.
-+char _Alignas (double) aligned_as_double;
-+char _Alignas (0) no_special_alignment;
-+extern char aligned_as_int;
-+char _Alignas (0) _Alignas (int) aligned_as_int;
-+
-+// Check _Alignof.
-+enum
-+{
-+  int_alignment = _Alignof (int),
-+  int_array_alignment = _Alignof (int[100]),
-+  char_alignment = _Alignof (char)
-+};
-+_Static_assert (0 < -_Alignof (int), "_Alignof is signed");
-+
-+// Check _Noreturn.
-+int _Noreturn does_not_return (void) { for (;;) continue; }
-+
-+// Check _Static_assert.
-+struct test_static_assert
-+{
-+  int x;
-+  _Static_assert (sizeof (int) <= sizeof (long int),
-+                  "_Static_assert does not work in struct");
-+  long int y;
-+};
-+
-+// Check UTF-8 literals.
-+#define u8 syntax error!
-+char const utf8_literal[] = u8"happens to be ASCII" "another string";
-+
-+// Check duplicate typedefs.
-+typedef long *long_ptr;
-+typedef long int *long_ptr;
-+typedef long_ptr long_ptr;
-+
-+// Anonymous structures and unions -- taken from C11 6.7.2.1 Example 1.
-+struct anonymous
-+{
-+  union {
-+    struct { int i; int j; };
-+    struct { int k; long int l; } w;
-+  };
-+  int m;
-+} v1;
-+'
-+
-+# Test code for whether the C compiler supports C11 (body of main).
-+ac_c_conftest_c11_main='
-+  _Static_assert ((offsetof (struct anonymous, i)
-+		   == offsetof (struct anonymous, w.k)),
-+		  "Anonymous union alignment botch");
-+  v1.i = 2;
-+  v1.w.k = 5;
-+  ok |= v1.i != 5;
-+'
-+
-+# Test code for whether the C compiler supports C11 (complete).
-+ac_c_conftest_c11_program="${ac_c_conftest_c89_globals}
-+${ac_c_conftest_c99_globals}
-+${ac_c_conftest_c11_globals}
-+
-+int
-+main (int argc, char **argv)
-+{
-+  int ok = 0;
-+  ${ac_c_conftest_c89_main}
-+  ${ac_c_conftest_c99_main}
-+  ${ac_c_conftest_c11_main}
-+  return ok;
-+}
-+"
-+
-+# Test code for whether the C compiler supports C99 (complete).
-+ac_c_conftest_c99_program="${ac_c_conftest_c89_globals}
-+${ac_c_conftest_c99_globals}
-+
-+int
-+main (int argc, char **argv)
-+{
-+  int ok = 0;
-+  ${ac_c_conftest_c89_main}
-+  ${ac_c_conftest_c99_main}
-+  return ok;
-+}
-+"
-+
-+# Test code for whether the C compiler supports C89 (complete).
-+ac_c_conftest_c89_program="${ac_c_conftest_c89_globals}
-+
-+int
-+main (int argc, char **argv)
-+{
-+  int ok = 0;
-+  ${ac_c_conftest_c89_main}
-+  return ok;
-+}
-+"
-+
-+# Test code for whether the C++ compiler supports C++98 (global declarations)
-+ac_cxx_conftest_cxx98_globals='
-+// Does the compiler advertise C++98 conformance?
-+#if !defined __cplusplus || __cplusplus < 199711L
-+# error "Compiler does not advertise C++98 conformance"
-+#endif
-+
-+// These inclusions are to reject old compilers that
-+// lack the unsuffixed header files.
-+#include <cstdlib>
-+#include <exception>
-+
-+// <cassert> and <cstring> are *not* freestanding headers in C++98.
-+extern void assert (int);
-+namespace std {
-+  extern int strcmp (const char *, const char *);
-+}
-+
-+// Namespaces, exceptions, and templates were all added after "C++ 2.0".
-+using std::exception;
-+using std::strcmp;
-+
-+namespace {
-+
-+void test_exception_syntax()
-+{
-+  try {
-+    throw "test";
-+  } catch (const char *s) {
-+    // Extra parentheses suppress a warning when building autoconf itself,
-+    // due to lint rules shared with more typical C programs.
-+    assert (!(strcmp) (s, "test"));
-+  }
-+}
-+
-+template <typename T> struct test_template
-+{
-+  T const val;
-+  explicit test_template(T t) : val(t) {}
-+  template <typename U> T add(U u) { return static_cast<T>(u) + val; }
-+};
-+
-+} // anonymous namespace
-+'
-+
-+# Test code for whether the C++ compiler supports C++98 (body of main)
-+ac_cxx_conftest_cxx98_main='
-+  assert (argc);
-+  assert (! argv[0]);
-+{
-+  test_exception_syntax ();
-+  test_template<double> tt (2.0);
-+  assert (tt.add (4) == 6.0);
-+  assert (true && !false);
-+}
-+'
-+
-+# Test code for whether the C++ compiler supports C++11 (global declarations)
-+ac_cxx_conftest_cxx11_globals='
-+// Does the compiler advertise C++ 2011 conformance?
-+#if !defined __cplusplus || __cplusplus < 201103L
-+# error "Compiler does not advertise C++11 conformance"
-+#endif
-+
-+namespace cxx11test
-+{
-+  constexpr int get_val() { return 20; }
-+
-+  struct testinit
-+  {
-+    int i;
-+    double d;
-+  };
-+
-+  class delegate
-+  {
-+  public:
-+    delegate(int n) : n(n) {}
-+    delegate(): delegate(2354) {}
-+
-+    virtual int getval() { return this->n; };
-+  protected:
-+    int n;
-+  };
-+
-+  class overridden : public delegate
-+  {
-+  public:
-+    overridden(int n): delegate(n) {}
-+    virtual int getval() override final { return this->n * 2; }
-+  };
-+
-+  class nocopy
-+  {
-+  public:
-+    nocopy(int i): i(i) {}
-+    nocopy() = default;
-+    nocopy(const nocopy&) = delete;
-+    nocopy & operator=(const nocopy&) = delete;
-+  private:
-+    int i;
-+  };
-+
-+  // for testing lambda expressions
-+  template <typename Ret, typename Fn> Ret eval(Fn f, Ret v)
-+  {
-+    return f(v);
-+  }
-+
-+  // for testing variadic templates and trailing return types
-+  template <typename V> auto sum(V first) -> V
-+  {
-+    return first;
-+  }
-+  template <typename V, typename... Args> auto sum(V first, Args... rest) -> V
-+  {
-+    return first + sum(rest...);
-+  }
-+}
-+'
-+
-+# Test code for whether the C++ compiler supports C++11 (body of main)
-+ac_cxx_conftest_cxx11_main='
-+{
-+  // Test auto and decltype
-+  auto a1 = 6538;
-+  auto a2 = 48573953.4;
-+  auto a3 = "String literal";
-+
-+  int total = 0;
-+  for (auto i = a3; *i; ++i) { total += *i; }
-+
-+  decltype(a2) a4 = 34895.034;
-+}
-+{
-+  // Test constexpr
-+  short sa[cxx11test::get_val()] = { 0 };
-+}
-+{
-+  // Test initializer lists
-+  cxx11test::testinit il = { 4323, 435234.23544 };
-+}
-+{
-+  // Test range-based for
-+  int array[] = {9, 7, 13, 15, 4, 18, 12, 10, 5, 3,
-+                 14, 19, 17, 8, 6, 20, 16, 2, 11, 1};
-+  for (auto &x : array) { x += 23; }
-+}
-+{
-+  // Test lambda expressions
-+  using cxx11test::eval;
-+  assert (eval ([](int x) { return x*2; }, 21) == 42);
-+  double d = 2.0;
-+  assert (eval ([&](double x) { return d += x; }, 3.0) == 5.0);
-+  assert (d == 5.0);
-+  assert (eval ([=](double x) mutable { return d += x; }, 4.0) == 9.0);
-+  assert (d == 5.0);
-+}
-+{
-+  // Test use of variadic templates
-+  using cxx11test::sum;
-+  auto a = sum(1);
-+  auto b = sum(1, 2);
-+  auto c = sum(1.0, 2.0, 3.0);
-+}
-+{
-+  // Test constructor delegation
-+  cxx11test::delegate d1;
-+  cxx11test::delegate d2();
-+  cxx11test::delegate d3(45);
-+}
-+{
-+  // Test override and final
-+  cxx11test::overridden o1(55464);
-+}
-+{
-+  // Test nullptr
-+  char *c = nullptr;
-+}
-+{
-+  // Test template brackets
-+  test_template<::test_template<int>> v(test_template<int>(12));
-+}
-+{
-+  // Unicode literals
-+  char const *utf8 = u8"UTF-8 string \u2500";
-+  char16_t const *utf16 = u"UTF-8 string \u2500";
-+  char32_t const *utf32 = U"UTF-32 string \u2500";
-+}
-+'
-+
-+# Test code for whether the C compiler supports C++11 (complete).
-+ac_cxx_conftest_cxx11_program="${ac_cxx_conftest_cxx98_globals}
-+${ac_cxx_conftest_cxx11_globals}
-+
-+int
-+main (int argc, char **argv)
-+{
-+  int ok = 0;
-+  ${ac_cxx_conftest_cxx98_main}
-+  ${ac_cxx_conftest_cxx11_main}
-+  return ok;
-+}
-+"
-+
-+# Test code for whether the C compiler supports C++98 (complete).
-+ac_cxx_conftest_cxx98_program="${ac_cxx_conftest_cxx98_globals}
-+int
-+main (int argc, char **argv)
-+{
-+  int ok = 0;
-+  ${ac_cxx_conftest_cxx98_main}
-+  return ok;
-+}
-+"
-+
-+as_fn_append ac_header_cxx_list " stdio.h stdio_h HAVE_STDIO_H"
-+as_fn_append ac_header_cxx_list " stdlib.h stdlib_h HAVE_STDLIB_H"
-+as_fn_append ac_header_cxx_list " string.h string_h HAVE_STRING_H"
-+as_fn_append ac_header_cxx_list " inttypes.h inttypes_h HAVE_INTTYPES_H"
-+as_fn_append ac_header_cxx_list " stdint.h stdint_h HAVE_STDINT_H"
-+as_fn_append ac_header_cxx_list " strings.h strings_h HAVE_STRINGS_H"
-+as_fn_append ac_header_cxx_list " sys/stat.h sys_stat_h HAVE_SYS_STAT_H"
-+as_fn_append ac_header_cxx_list " sys/types.h sys_types_h HAVE_SYS_TYPES_H"
-+as_fn_append ac_header_cxx_list " unistd.h unistd_h HAVE_UNISTD_H"
-+
-+# Auxiliary files required by this configure script.
-+ac_aux_files="config.guess config.sub"
-+
-+# Locations in which to look for auxiliary files.
-+ac_aux_dir_candidates="$TOPDIR/common/autoconf/build-aux"
-+
-+# Search for a directory containing all of the required auxiliary files,
-+# $ac_aux_files, from the $PATH-style list $ac_aux_dir_candidates.
-+# If we don't find one directory that contains all the files we need,
-+# we report the set of missing files from the *first* directory in
-+# $ac_aux_dir_candidates and give up.
-+ac_missing_aux_files=""
-+ac_first_candidate=:
-+printf "%s\n" "$as_me:${as_lineno-$LINENO}: looking for aux files: $ac_aux_files" >&5
-+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-+as_found=false
-+for as_dir in $ac_aux_dir_candidates
-+do
-+  IFS=$as_save_IFS
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-+  as_found=:
-+
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}:  trying $as_dir" >&5
-+  ac_aux_dir_found=yes
-+  ac_install_sh=
-+  for ac_aux in $ac_aux_files
-+  do
-+    # As a special case, if "install-sh" is required, that requirement
-+    # can be satisfied by any of "install-sh", "install.sh", or "shtool",
-+    # and $ac_install_sh is set appropriately for whichever one is found.
-+    if test x"$ac_aux" = x"install-sh"
-+    then
-+      if test -f "${as_dir}install-sh"; then
-+        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}install-sh found" >&5
-+        ac_install_sh="${as_dir}install-sh -c"
-+      elif test -f "${as_dir}install.sh"; then
-+        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}install.sh found" >&5
-+        ac_install_sh="${as_dir}install.sh -c"
-+      elif test -f "${as_dir}shtool"; then
-+        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}shtool found" >&5
-+        ac_install_sh="${as_dir}shtool install -c"
-+      else
-+        ac_aux_dir_found=no
-+        if $ac_first_candidate; then
-+          ac_missing_aux_files="${ac_missing_aux_files} install-sh"
-+        else
-+          break
-+        fi
-+      fi
-+    else
-+      if test -f "${as_dir}${ac_aux}"; then
-+        printf "%s\n" "$as_me:${as_lineno-$LINENO}:   ${as_dir}${ac_aux} found" >&5
-+      else
-+        ac_aux_dir_found=no
-+        if $ac_first_candidate; then
-+          ac_missing_aux_files="${ac_missing_aux_files} ${ac_aux}"
-+        else
-+          break
-+        fi
-+      fi
-+    fi
-+  done
-+  if test "$ac_aux_dir_found" = yes; then
-+    ac_aux_dir="$as_dir"
-+    break
-+  fi
-+  ac_first_candidate=false
-+
-+  as_found=false
-+done
-+IFS=$as_save_IFS
-+if $as_found
-+then :
-+
-+else case e in #(
-+  e) as_fn_error $? "cannot find required auxiliary files:$ac_missing_aux_files" "$LINENO" 5 ;;
-+esac
-+fi
-+
-+
-+# These three variables are undocumented and unsupported,
-+# and are intended to be withdrawn in a future Autoconf release.
-+# They can cause serious problems if a builder's source tree is in a directory
-+# whose full name contains unusual characters.
-+if test -f "${ac_aux_dir}config.guess"; then
-+  ac_config_guess="$SHELL ${ac_aux_dir}config.guess"
-+fi
-+if test -f "${ac_aux_dir}config.sub"; then
-+  ac_config_sub="$SHELL ${ac_aux_dir}config.sub"
-+fi
-+if test -f "$ac_aux_dir/configure"; then
-+  ac_configure="$SHELL ${ac_aux_dir}configure"
-+fi
-+
- # Check that the precious variables saved in the cache have kept the same
- # value.
- ac_cache_corrupted=false
-@@ -3167,12 +3802,12 @@ for ac_var in $ac_precious_vars; do
-   eval ac_new_val=\$ac_env_${ac_var}_value
-   case $ac_old_set,$ac_new_set in
-     set,)
--      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
--$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&5
-+printf "%s\n" "$as_me: error: '$ac_var' was set to '$ac_old_val' in the previous run" >&2;}
-       ac_cache_corrupted=: ;;
-     ,set)
--      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
--$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' was not set in the previous run" >&5
-+printf "%s\n" "$as_me: error: '$ac_var' was not set in the previous run" >&2;}
-       ac_cache_corrupted=: ;;
-     ,);;
-     *)
-@@ -3181,24 +3816,24 @@ $as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
- 	ac_old_val_w=`echo x $ac_old_val`
- 	ac_new_val_w=`echo x $ac_new_val`
- 	if test "$ac_old_val_w" != "$ac_new_val_w"; then
--	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
--$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
-+	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: '$ac_var' has changed since the previous run:" >&5
-+printf "%s\n" "$as_me: error: '$ac_var' has changed since the previous run:" >&2;}
- 	  ac_cache_corrupted=:
- 	else
--	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
--$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
-+	  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&5
-+printf "%s\n" "$as_me: warning: ignoring whitespace changes in '$ac_var' since the previous run:" >&2;}
- 	  eval $ac_var=\$ac_old_val
- 	fi
--	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
--$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
--	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
--$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
-+	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}:   former value:  '$ac_old_val'" >&5
-+printf "%s\n" "$as_me:   former value:  '$ac_old_val'" >&2;}
-+	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}:   current value: '$ac_new_val'" >&5
-+printf "%s\n" "$as_me:   current value: '$ac_new_val'" >&2;}
-       fi;;
-   esac
-   # Pass precious variables to config.status.
-   if test "$ac_new_set" = set; then
-     case $ac_new_val in
--    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
-+    *\'*) ac_arg=$ac_var=`printf "%s\n" "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
-     *) ac_arg=$ac_var=$ac_new_val ;;
-     esac
-     case " $ac_configure_args " in
-@@ -3208,11 +3843,12 @@ $as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
-   fi
- done
- if $ac_cache_corrupted; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
--$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
--  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
--$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
--  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
-+printf "%s\n" "$as_me: error: changes in the environment can compromise the build" >&2;}
-+  as_fn_error $? "run '${MAKE-make} distclean' and/or 'rm $cache_file'
-+	    and start over" "$LINENO" 5
- fi
- ## -------------------- ##
- ## Main body of script. ##
-@@ -3226,34 +3862,6 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
- 
- 
- 
--ac_aux_dir=
--for ac_dir in $TOPDIR/common/autoconf/build-aux "$srcdir"/$TOPDIR/common/autoconf/build-aux; do
--  if test -f "$ac_dir/install-sh"; then
--    ac_aux_dir=$ac_dir
--    ac_install_sh="$ac_aux_dir/install-sh -c"
--    break
--  elif test -f "$ac_dir/install.sh"; then
--    ac_aux_dir=$ac_dir
--    ac_install_sh="$ac_aux_dir/install.sh -c"
--    break
--  elif test -f "$ac_dir/shtool"; then
--    ac_aux_dir=$ac_dir
--    ac_install_sh="$ac_aux_dir/shtool install -c"
--    break
--  fi
--done
--if test -z "$ac_aux_dir"; then
--  as_fn_error $? "cannot find install-sh, install.sh, or shtool in $TOPDIR/common/autoconf/build-aux \"$srcdir\"/$TOPDIR/common/autoconf/build-aux" "$LINENO" 5
--fi
--
--# These three variables are undocumented and unsupported,
--# and are intended to be withdrawn in a future Autoconf release.
--# They can cause serious problems if a builder's source tree is in a directory
--# whose full name contains unusual characters.
--ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
--ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
--ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
--
- 
- # pkg.m4 - Macros to locate and utilise pkg-config.            -*- Autoconf -*-
- 
-@@ -3972,7 +4580,8 @@ pkgadd_help() {
- # to create them
- 
- # Check whether --with-custom-make-dir was given.
--if test "${with_custom_make_dir+set}" = set; then :
-+if test ${with_custom_make_dir+y}
-+then :
-   withval=$with_custom_make_dir; CUSTOM_MAKE_DIR=$with_custom_make_dir
- fi
- 
-@@ -4061,6 +4670,11 @@ fi
- # VAR_OS and VAR_OS_API.
- 
- 
-+# Support macro for PLATFORM_EXTRACT_TARGET_AND_BUILD.
-+# Converts autoconf style OS name to OpenJDK style, into
-+# VAR_LIBC.
-+
-+
- # Expects $host_os $host_cpu $build_os and $build_cpu
- # and $with_target_bits to have been setup!
- #
-@@ -4410,7 +5024,7 @@ VS_TOOLSET_SUPPORTED_2022=true
- #CUSTOM_AUTOCONF_INCLUDE
- 
- # Do not change or remove the following line, it is needed for consistency checks:
--DATE_WHEN_GENERATED=1779849897
-+DATE_WHEN_GENERATED=1781625962
- 
- ###############################################################################
- #
-@@ -4445,10 +5059,10 @@ DATE_WHEN_GENERATED=1779849897
- 
-   DATE_WHEN_CONFIGURED=`LANG=C date`
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
--$as_echo "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
--  { $as_echo "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
--$as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Configuration created at $DATE_WHEN_CONFIGURED." >&5
-+printf "%s\n" "$as_me: Configuration created at $DATE_WHEN_CONFIGURED." >&6;}
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: configure script generated at timestamp $DATE_WHEN_GENERATED." >&5
-+printf "%s\n" "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED." >&6;}
- 
- 
-   # Start with tools that do not need have cross compilation support
-@@ -4470,12 +5084,13 @@ $as_echo "$as_me: configure script generated at timestamp $DATE_WHEN_GENERATED."
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BASENAME+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BASENAME in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BASENAME+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BASENAME in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
-   ;;
-@@ -4484,11 +5099,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BASENAME="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -4496,15 +5115,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BASENAME=$ac_cv_path_BASENAME
- if test -n "$BASENAME"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
--$as_echo "$BASENAME" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
-+printf "%s\n" "$BASENAME" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -4520,20 +5140,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xBASENAME" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of BASENAME from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in basename
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BASENAME+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BASENAME in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BASENAME+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BASENAME in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
-   ;;
-@@ -4542,11 +5163,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BASENAME="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -4554,15 +5179,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BASENAME=$ac_cv_path_BASENAME
- if test -n "$BASENAME"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
--$as_echo "$BASENAME" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
-+printf "%s\n" "$BASENAME" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -4582,16 +5208,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASENAME=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool BASENAME=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BASENAME+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BASENAME in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BASENAME+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BASENAME in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BASENAME="$BASENAME" # Let the user override the test with a path.
-   ;;
-@@ -4600,11 +5227,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BASENAME="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BASENAME="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -4612,15 +5243,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BASENAME=$ac_cv_path_BASENAME
- if test -n "$BASENAME"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
--$as_echo "$BASENAME" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BASENAME" >&5
-+printf "%s\n" "$BASENAME" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -4629,17 +5261,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
--$as_echo_n "checking for BASENAME... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASENAME=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool BASENAME=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BASENAME" >&5
-+printf %s "checking for BASENAME... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool BASENAME=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -4663,12 +5295,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BASH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BASH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BASH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BASH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
-   ;;
-@@ -4677,11 +5310,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BASH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -4689,15 +5326,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BASH=$ac_cv_path_BASH
- if test -n "$BASH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
--$as_echo "$BASH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
-+printf "%s\n" "$BASH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -4713,20 +5351,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xBASH" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of BASH from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in bash
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BASH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BASH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BASH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BASH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
-   ;;
-@@ -4735,11 +5374,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BASH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -4747,15 +5390,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BASH=$ac_cv_path_BASH
- if test -n "$BASH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
--$as_echo "$BASH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
-+printf "%s\n" "$BASH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -4775,16 +5419,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BASH=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool BASH=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BASH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BASH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BASH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BASH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BASH="$BASH" # Let the user override the test with a path.
-   ;;
-@@ -4793,11 +5438,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BASH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BASH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -4805,15 +5454,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BASH=$ac_cv_path_BASH
- if test -n "$BASH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
--$as_echo "$BASH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BASH" >&5
-+printf "%s\n" "$BASH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -4822,17 +5472,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
--$as_echo_n "checking for BASH... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BASH=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool BASH=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BASH" >&5
-+printf %s "checking for BASH... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool BASH=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -4856,12 +5506,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CAT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CAT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CAT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CAT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
-   ;;
-@@ -4870,11 +5521,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CAT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -4882,15 +5537,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CAT=$ac_cv_path_CAT
- if test -n "$CAT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
--$as_echo "$CAT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
-+printf "%s\n" "$CAT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -4906,20 +5562,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xCAT" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of CAT from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in cat
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CAT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CAT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CAT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CAT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
-   ;;
-@@ -4928,11 +5585,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CAT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -4940,15 +5601,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CAT=$ac_cv_path_CAT
- if test -n "$CAT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
--$as_echo "$CAT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
-+printf "%s\n" "$CAT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -4968,16 +5630,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CAT=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool CAT=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CAT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CAT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CAT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CAT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CAT="$CAT" # Let the user override the test with a path.
-   ;;
-@@ -4986,11 +5649,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CAT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CAT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -4998,15 +5665,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CAT=$ac_cv_path_CAT
- if test -n "$CAT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
--$as_echo "$CAT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CAT" >&5
-+printf "%s\n" "$CAT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5015,17 +5683,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
--$as_echo_n "checking for CAT... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CAT=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool CAT=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CAT" >&5
-+printf %s "checking for CAT... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool CAT=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -5049,12 +5717,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CHMOD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CHMOD in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CHMOD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CHMOD in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
-   ;;
-@@ -5063,11 +5732,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CHMOD="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5075,15 +5748,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CHMOD=$ac_cv_path_CHMOD
- if test -n "$CHMOD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
--$as_echo "$CHMOD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
-+printf "%s\n" "$CHMOD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5099,20 +5773,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xCHMOD" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of CHMOD from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in chmod
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CHMOD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CHMOD in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CHMOD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CHMOD in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
-   ;;
-@@ -5121,11 +5796,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CHMOD="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5133,15 +5812,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CHMOD=$ac_cv_path_CHMOD
- if test -n "$CHMOD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
--$as_echo "$CHMOD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
-+printf "%s\n" "$CHMOD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5161,16 +5841,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CHMOD=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool CHMOD=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CHMOD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CHMOD in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CHMOD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CHMOD in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CHMOD="$CHMOD" # Let the user override the test with a path.
-   ;;
-@@ -5179,11 +5860,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CHMOD="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CHMOD="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5191,15 +5876,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CHMOD=$ac_cv_path_CHMOD
- if test -n "$CHMOD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
--$as_echo "$CHMOD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHMOD" >&5
-+printf "%s\n" "$CHMOD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5208,17 +5894,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
--$as_echo_n "checking for CHMOD... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CHMOD=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool CHMOD=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CHMOD" >&5
-+printf %s "checking for CHMOD... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool CHMOD=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -5242,12 +5928,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CMP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CMP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CMP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CMP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
-   ;;
-@@ -5256,11 +5943,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CMP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5268,15 +5959,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CMP=$ac_cv_path_CMP
- if test -n "$CMP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
--$as_echo "$CMP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
-+printf "%s\n" "$CMP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5292,20 +5984,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xCMP" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of CMP from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in cmp
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CMP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CMP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CMP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CMP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
-   ;;
-@@ -5314,11 +6007,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CMP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5326,15 +6023,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CMP=$ac_cv_path_CMP
- if test -n "$CMP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
--$as_echo "$CMP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
-+printf "%s\n" "$CMP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5354,16 +6052,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CMP=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool CMP=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CMP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CMP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CMP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CMP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CMP="$CMP" # Let the user override the test with a path.
-   ;;
-@@ -5372,11 +6071,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CMP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CMP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5384,15 +6087,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CMP=$ac_cv_path_CMP
- if test -n "$CMP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
--$as_echo "$CMP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CMP" >&5
-+printf "%s\n" "$CMP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5401,17 +6105,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
--$as_echo_n "checking for CMP... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CMP=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool CMP=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CMP" >&5
-+printf %s "checking for CMP... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool CMP=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -5435,12 +6139,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_COMM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $COMM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_COMM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $COMM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
-   ;;
-@@ -5449,11 +6154,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_COMM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5461,15 +6170,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- COMM=$ac_cv_path_COMM
- if test -n "$COMM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
--$as_echo "$COMM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
-+printf "%s\n" "$COMM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5485,20 +6195,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xCOMM" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in comm
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_COMM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $COMM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_COMM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $COMM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
-   ;;
-@@ -5507,11 +6218,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_COMM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5519,15 +6234,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- COMM=$ac_cv_path_COMM
- if test -n "$COMM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
--$as_echo "$COMM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
-+printf "%s\n" "$COMM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5547,16 +6263,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_COMM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $COMM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_COMM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $COMM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
-   ;;
-@@ -5565,11 +6282,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_COMM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5577,15 +6298,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- COMM=$ac_cv_path_COMM
- if test -n "$COMM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
--$as_echo "$COMM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
-+printf "%s\n" "$COMM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5594,17 +6316,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
--$as_echo_n "checking for COMM... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
-+printf %s "checking for COMM... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -5628,12 +6350,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CP="$CP" # Let the user override the test with a path.
-   ;;
-@@ -5642,11 +6365,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5654,15 +6381,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CP=$ac_cv_path_CP
- if test -n "$CP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
--$as_echo "$CP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
-+printf "%s\n" "$CP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5678,20 +6406,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xCP" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of CP from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in cp
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CP="$CP" # Let the user override the test with a path.
-   ;;
-@@ -5700,11 +6429,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5712,15 +6445,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CP=$ac_cv_path_CP
- if test -n "$CP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
--$as_echo "$CP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
-+printf "%s\n" "$CP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5740,16 +6474,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CP=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool CP=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CP="$CP" # Let the user override the test with a path.
-   ;;
-@@ -5758,11 +6493,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5770,15 +6509,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CP=$ac_cv_path_CP
- if test -n "$CP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
--$as_echo "$CP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CP" >&5
-+printf "%s\n" "$CP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5787,17 +6527,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
--$as_echo_n "checking for CP... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CP=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool CP=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CP" >&5
-+printf %s "checking for CP... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool CP=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -5821,12 +6561,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CUT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CUT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CUT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CUT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
-   ;;
-@@ -5835,11 +6576,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CUT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5847,15 +6592,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CUT=$ac_cv_path_CUT
- if test -n "$CUT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
--$as_echo "$CUT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
-+printf "%s\n" "$CUT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5871,20 +6617,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xCUT" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of CUT from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in cut
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CUT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CUT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CUT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CUT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
-   ;;
-@@ -5893,11 +6640,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CUT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5905,15 +6656,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CUT=$ac_cv_path_CUT
- if test -n "$CUT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
--$as_echo "$CUT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
-+printf "%s\n" "$CUT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5933,16 +6685,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CUT=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool CUT=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CUT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CUT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CUT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CUT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CUT="$CUT" # Let the user override the test with a path.
-   ;;
-@@ -5951,11 +6704,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CUT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CUT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -5963,15 +6720,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CUT=$ac_cv_path_CUT
- if test -n "$CUT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
--$as_echo "$CUT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CUT" >&5
-+printf "%s\n" "$CUT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -5980,17 +6738,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
--$as_echo_n "checking for CUT... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CUT=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool CUT=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CUT" >&5
-+printf %s "checking for CUT... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool CUT=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -6014,12 +6772,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DATE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DATE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DATE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DATE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
-   ;;
-@@ -6028,11 +6787,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DATE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6040,15 +6803,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DATE=$ac_cv_path_DATE
- if test -n "$DATE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
--$as_echo "$DATE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
-+printf "%s\n" "$DATE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6064,20 +6828,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xDATE" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of DATE from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in date
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DATE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DATE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DATE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DATE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
-   ;;
-@@ -6086,11 +6851,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DATE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6098,15 +6867,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DATE=$ac_cv_path_DATE
- if test -n "$DATE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
--$as_echo "$DATE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
-+printf "%s\n" "$DATE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6126,16 +6896,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DATE=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool DATE=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DATE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DATE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DATE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DATE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DATE="$DATE" # Let the user override the test with a path.
-   ;;
-@@ -6144,11 +6915,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DATE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DATE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6156,15 +6931,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DATE=$ac_cv_path_DATE
- if test -n "$DATE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
--$as_echo "$DATE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DATE" >&5
-+printf "%s\n" "$DATE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6173,17 +6949,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
--$as_echo_n "checking for DATE... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DATE=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool DATE=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for DATE" >&5
-+printf %s "checking for DATE... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool DATE=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -6207,12 +6983,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DIFF+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DIFF in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DIFF+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DIFF in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
-   ;;
-@@ -6221,11 +6998,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DIFF="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6233,15 +7014,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DIFF=$ac_cv_path_DIFF
- if test -n "$DIFF"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
--$as_echo "$DIFF" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
-+printf "%s\n" "$DIFF" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6257,20 +7039,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xDIFF" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of DIFF from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in gdiff diff
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DIFF+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DIFF in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DIFF+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DIFF in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
-   ;;
-@@ -6279,11 +7062,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DIFF="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6291,15 +7078,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DIFF=$ac_cv_path_DIFF
- if test -n "$DIFF"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
--$as_echo "$DIFF" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
-+printf "%s\n" "$DIFF" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6319,16 +7107,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIFF=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool DIFF=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DIFF+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DIFF in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DIFF+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DIFF in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DIFF="$DIFF" # Let the user override the test with a path.
-   ;;
-@@ -6337,11 +7126,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DIFF="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DIFF="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6349,15 +7142,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DIFF=$ac_cv_path_DIFF
- if test -n "$DIFF"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
--$as_echo "$DIFF" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DIFF" >&5
-+printf "%s\n" "$DIFF" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6366,17 +7160,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
--$as_echo_n "checking for DIFF... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIFF=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool DIFF=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for DIFF" >&5
-+printf %s "checking for DIFF... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool DIFF=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -6400,12 +7194,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DIRNAME+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DIRNAME in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DIRNAME+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DIRNAME in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
-   ;;
-@@ -6414,11 +7209,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DIRNAME="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6426,15 +7225,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DIRNAME=$ac_cv_path_DIRNAME
- if test -n "$DIRNAME"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
--$as_echo "$DIRNAME" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
-+printf "%s\n" "$DIRNAME" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6450,20 +7250,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xDIRNAME" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of DIRNAME from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in dirname
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DIRNAME+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DIRNAME in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DIRNAME+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DIRNAME in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
-   ;;
-@@ -6472,11 +7273,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DIRNAME="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6484,15 +7289,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DIRNAME=$ac_cv_path_DIRNAME
- if test -n "$DIRNAME"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
--$as_echo "$DIRNAME" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
-+printf "%s\n" "$DIRNAME" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6512,16 +7318,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DIRNAME=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool DIRNAME=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DIRNAME+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DIRNAME in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DIRNAME+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DIRNAME in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DIRNAME="$DIRNAME" # Let the user override the test with a path.
-   ;;
-@@ -6530,11 +7337,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DIRNAME="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DIRNAME="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6542,15 +7353,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DIRNAME=$ac_cv_path_DIRNAME
- if test -n "$DIRNAME"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
--$as_echo "$DIRNAME" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DIRNAME" >&5
-+printf "%s\n" "$DIRNAME" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6559,17 +7371,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
--$as_echo_n "checking for DIRNAME... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DIRNAME=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool DIRNAME=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for DIRNAME" >&5
-+printf %s "checking for DIRNAME... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool DIRNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -6593,12 +7405,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_ECHO+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $ECHO in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_ECHO+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $ECHO in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
-   ;;
-@@ -6607,11 +7420,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_ECHO="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6619,15 +7436,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- ECHO=$ac_cv_path_ECHO
- if test -n "$ECHO"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
--$as_echo "$ECHO" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
-+printf "%s\n" "$ECHO" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6643,20 +7461,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xECHO" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of ECHO from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in echo
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_ECHO+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $ECHO in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_ECHO+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $ECHO in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
-   ;;
-@@ -6665,11 +7484,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_ECHO="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6677,15 +7500,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- ECHO=$ac_cv_path_ECHO
- if test -n "$ECHO"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
--$as_echo "$ECHO" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
-+printf "%s\n" "$ECHO" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6705,16 +7529,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ECHO=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool ECHO=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_ECHO+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $ECHO in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_ECHO+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $ECHO in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_ECHO="$ECHO" # Let the user override the test with a path.
-   ;;
-@@ -6723,11 +7548,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_ECHO="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_ECHO="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6735,15 +7564,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- ECHO=$ac_cv_path_ECHO
- if test -n "$ECHO"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
--$as_echo "$ECHO" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ECHO" >&5
-+printf "%s\n" "$ECHO" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6752,17 +7582,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
--$as_echo_n "checking for ECHO... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ECHO=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool ECHO=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ECHO" >&5
-+printf %s "checking for ECHO... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool ECHO=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -6786,12 +7616,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_EXPR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $EXPR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_EXPR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $EXPR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
-   ;;
-@@ -6800,11 +7631,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_EXPR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6812,15 +7647,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- EXPR=$ac_cv_path_EXPR
- if test -n "$EXPR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
--$as_echo "$EXPR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
-+printf "%s\n" "$EXPR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6836,20 +7672,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xEXPR" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of EXPR from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in expr
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_EXPR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $EXPR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_EXPR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $EXPR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
-   ;;
-@@ -6858,11 +7695,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_EXPR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6870,15 +7711,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- EXPR=$ac_cv_path_EXPR
- if test -n "$EXPR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
--$as_echo "$EXPR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
-+printf "%s\n" "$EXPR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6898,16 +7740,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EXPR=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool EXPR=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_EXPR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $EXPR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_EXPR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $EXPR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_EXPR="$EXPR" # Let the user override the test with a path.
-   ;;
-@@ -6916,11 +7759,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_EXPR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_EXPR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -6928,15 +7775,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- EXPR=$ac_cv_path_EXPR
- if test -n "$EXPR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
--$as_echo "$EXPR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $EXPR" >&5
-+printf "%s\n" "$EXPR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -6945,17 +7793,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
--$as_echo_n "checking for EXPR... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EXPR=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool EXPR=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for EXPR" >&5
-+printf %s "checking for EXPR... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool EXPR=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -6979,12 +7827,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_FILE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $FILE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_FILE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $FILE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
-   ;;
-@@ -6993,11 +7842,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_FILE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7005,15 +7858,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- FILE=$ac_cv_path_FILE
- if test -n "$FILE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
--$as_echo "$FILE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
-+printf "%s\n" "$FILE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7029,20 +7883,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xFILE" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of FILE from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in file
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_FILE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $FILE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_FILE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $FILE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
-   ;;
-@@ -7051,11 +7906,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_FILE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7063,15 +7922,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- FILE=$ac_cv_path_FILE
- if test -n "$FILE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
--$as_echo "$FILE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
-+printf "%s\n" "$FILE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7091,16 +7951,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FILE=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool FILE=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_FILE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $FILE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_FILE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $FILE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_FILE="$FILE" # Let the user override the test with a path.
-   ;;
-@@ -7109,11 +7970,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_FILE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_FILE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7121,15 +7986,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- FILE=$ac_cv_path_FILE
- if test -n "$FILE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
--$as_echo "$FILE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FILE" >&5
-+printf "%s\n" "$FILE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7138,17 +8004,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
--$as_echo_n "checking for FILE... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FILE=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool FILE=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for FILE" >&5
-+printf %s "checking for FILE... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool FILE=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -7172,12 +8038,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_FIND+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $FIND in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_FIND+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $FIND in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
-   ;;
-@@ -7186,11 +8053,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_FIND="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7198,15 +8069,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- FIND=$ac_cv_path_FIND
- if test -n "$FIND"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
--$as_echo "$FIND" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
-+printf "%s\n" "$FIND" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7222,20 +8094,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xFIND" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of FIND from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in find
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_FIND+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $FIND in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_FIND+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $FIND in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
-   ;;
-@@ -7244,11 +8117,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_FIND="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7256,15 +8133,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- FIND=$ac_cv_path_FIND
- if test -n "$FIND"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
--$as_echo "$FIND" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
-+printf "%s\n" "$FIND" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7284,16 +8162,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FIND=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool FIND=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_FIND+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $FIND in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_FIND+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $FIND in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_FIND="$FIND" # Let the user override the test with a path.
-   ;;
-@@ -7302,11 +8181,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_FIND="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_FIND="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7314,15 +8197,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- FIND=$ac_cv_path_FIND
- if test -n "$FIND"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
--$as_echo "$FIND" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FIND" >&5
-+printf "%s\n" "$FIND" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7331,17 +8215,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
--$as_echo_n "checking for FIND... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FIND=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool FIND=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for FIND" >&5
-+printf %s "checking for FIND... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool FIND=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -7365,12 +8249,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_HEAD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $HEAD in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_HEAD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $HEAD in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
-   ;;
-@@ -7379,11 +8264,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_HEAD="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7391,15 +8280,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- HEAD=$ac_cv_path_HEAD
- if test -n "$HEAD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
--$as_echo "$HEAD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
-+printf "%s\n" "$HEAD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7415,20 +8305,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xHEAD" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of HEAD from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in head
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_HEAD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $HEAD in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_HEAD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $HEAD in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
-   ;;
-@@ -7437,11 +8328,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_HEAD="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7449,15 +8344,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- HEAD=$ac_cv_path_HEAD
- if test -n "$HEAD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
--$as_echo "$HEAD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
-+printf "%s\n" "$HEAD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7477,16 +8373,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HEAD=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool HEAD=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_HEAD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $HEAD in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_HEAD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $HEAD in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_HEAD="$HEAD" # Let the user override the test with a path.
-   ;;
-@@ -7495,11 +8392,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_HEAD="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_HEAD="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7507,15 +8408,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- HEAD=$ac_cv_path_HEAD
- if test -n "$HEAD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
--$as_echo "$HEAD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HEAD" >&5
-+printf "%s\n" "$HEAD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7524,17 +8426,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
--$as_echo_n "checking for HEAD... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HEAD=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool HEAD=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for HEAD" >&5
-+printf %s "checking for HEAD... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool HEAD=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -7558,12 +8460,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_LN+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $LN in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_LN+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $LN in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_LN="$LN" # Let the user override the test with a path.
-   ;;
-@@ -7572,11 +8475,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_LN="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7584,15 +8491,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- LN=$ac_cv_path_LN
- if test -n "$LN"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
--$as_echo "$LN" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
-+printf "%s\n" "$LN" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7608,20 +8516,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xLN" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of LN from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in ln
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_LN+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $LN in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_LN+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $LN in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_LN="$LN" # Let the user override the test with a path.
-   ;;
-@@ -7630,11 +8539,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_LN="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7642,15 +8555,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- LN=$ac_cv_path_LN
- if test -n "$LN"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
--$as_echo "$LN" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
-+printf "%s\n" "$LN" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7670,16 +8584,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LN=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool LN=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_LN+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $LN in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_LN+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $LN in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_LN="$LN" # Let the user override the test with a path.
-   ;;
-@@ -7688,11 +8603,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_LN="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_LN="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7700,15 +8619,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- LN=$ac_cv_path_LN
- if test -n "$LN"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
--$as_echo "$LN" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LN" >&5
-+printf "%s\n" "$LN" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7717,17 +8637,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
--$as_echo_n "checking for LN... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LN=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool LN=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for LN" >&5
-+printf %s "checking for LN... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool LN=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -7751,12 +8671,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_LS+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $LS in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_LS+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $LS in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_LS="$LS" # Let the user override the test with a path.
-   ;;
-@@ -7765,11 +8686,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_LS="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7777,15 +8702,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- LS=$ac_cv_path_LS
- if test -n "$LS"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
--$as_echo "$LS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
-+printf "%s\n" "$LS" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7801,20 +8727,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xLS" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of LS from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in ls
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_LS+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $LS in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_LS+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $LS in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_LS="$LS" # Let the user override the test with a path.
-   ;;
-@@ -7823,11 +8750,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_LS="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7835,15 +8766,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- LS=$ac_cv_path_LS
- if test -n "$LS"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
--$as_echo "$LS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
-+printf "%s\n" "$LS" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7863,16 +8795,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LS=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool LS=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_LS+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $LS in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_LS+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $LS in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_LS="$LS" # Let the user override the test with a path.
-   ;;
-@@ -7881,11 +8814,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_LS="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_LS="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7893,15 +8830,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- LS=$ac_cv_path_LS
- if test -n "$LS"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
--$as_echo "$LS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LS" >&5
-+printf "%s\n" "$LS" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7910,17 +8848,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
--$as_echo_n "checking for LS... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LS=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool LS=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for LS" >&5
-+printf %s "checking for LS... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool LS=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -7944,12 +8882,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_MKDIR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $MKDIR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_MKDIR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $MKDIR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
-   ;;
-@@ -7958,11 +8897,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_MKDIR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -7970,15 +8913,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- MKDIR=$ac_cv_path_MKDIR
- if test -n "$MKDIR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
--$as_echo "$MKDIR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
-+printf "%s\n" "$MKDIR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -7994,20 +8938,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xMKDIR" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of MKDIR from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in mkdir
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_MKDIR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $MKDIR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_MKDIR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $MKDIR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
-   ;;
-@@ -8016,11 +8961,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_MKDIR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8028,15 +8977,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- MKDIR=$ac_cv_path_MKDIR
- if test -n "$MKDIR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
--$as_echo "$MKDIR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
-+printf "%s\n" "$MKDIR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8056,16 +9006,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKDIR=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool MKDIR=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_MKDIR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $MKDIR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_MKDIR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $MKDIR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_MKDIR="$MKDIR" # Let the user override the test with a path.
-   ;;
-@@ -8074,11 +9025,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_MKDIR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_MKDIR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8086,15 +9041,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- MKDIR=$ac_cv_path_MKDIR
- if test -n "$MKDIR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
--$as_echo "$MKDIR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKDIR" >&5
-+printf "%s\n" "$MKDIR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8103,17 +9059,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
--$as_echo_n "checking for MKDIR... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKDIR=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool MKDIR=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for MKDIR" >&5
-+printf %s "checking for MKDIR... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool MKDIR=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -8137,12 +9093,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_MKTEMP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $MKTEMP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_MKTEMP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $MKTEMP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
-   ;;
-@@ -8151,11 +9108,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_MKTEMP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8163,15 +9124,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- MKTEMP=$ac_cv_path_MKTEMP
- if test -n "$MKTEMP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
--$as_echo "$MKTEMP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
-+printf "%s\n" "$MKTEMP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8187,20 +9149,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xMKTEMP" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of MKTEMP from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in mktemp
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_MKTEMP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $MKTEMP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_MKTEMP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $MKTEMP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
-   ;;
-@@ -8209,11 +9172,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_MKTEMP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8221,15 +9188,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- MKTEMP=$ac_cv_path_MKTEMP
- if test -n "$MKTEMP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
--$as_echo "$MKTEMP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
-+printf "%s\n" "$MKTEMP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8249,16 +9217,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MKTEMP=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool MKTEMP=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_MKTEMP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $MKTEMP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_MKTEMP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $MKTEMP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_MKTEMP="$MKTEMP" # Let the user override the test with a path.
-   ;;
-@@ -8267,11 +9236,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_MKTEMP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_MKTEMP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8279,15 +9252,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- MKTEMP=$ac_cv_path_MKTEMP
- if test -n "$MKTEMP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
--$as_echo "$MKTEMP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MKTEMP" >&5
-+printf "%s\n" "$MKTEMP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8296,17 +9270,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
--$as_echo_n "checking for MKTEMP... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MKTEMP=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool MKTEMP=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for MKTEMP" >&5
-+printf %s "checking for MKTEMP... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool MKTEMP=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -8330,12 +9304,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_MV+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $MV in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_MV+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $MV in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_MV="$MV" # Let the user override the test with a path.
-   ;;
-@@ -8344,11 +9319,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_MV="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8356,15 +9335,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- MV=$ac_cv_path_MV
- if test -n "$MV"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
--$as_echo "$MV" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
-+printf "%s\n" "$MV" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8380,20 +9360,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xMV" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of MV from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in mv
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_MV+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $MV in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_MV+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $MV in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_MV="$MV" # Let the user override the test with a path.
-   ;;
-@@ -8402,11 +9383,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_MV="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8414,15 +9399,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- MV=$ac_cv_path_MV
- if test -n "$MV"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
--$as_echo "$MV" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
-+printf "%s\n" "$MV" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8442,16 +9428,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MV=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool MV=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_MV+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $MV in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_MV+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $MV in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_MV="$MV" # Let the user override the test with a path.
-   ;;
-@@ -8460,11 +9447,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_MV="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_MV="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8472,15 +9463,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- MV=$ac_cv_path_MV
- if test -n "$MV"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
--$as_echo "$MV" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MV" >&5
-+printf "%s\n" "$MV" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8489,17 +9481,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
--$as_echo_n "checking for MV... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MV=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool MV=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for MV" >&5
-+printf %s "checking for MV... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool MV=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -8523,12 +9515,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_NAWK+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $NAWK in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_NAWK+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $NAWK in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
-   ;;
-@@ -8537,11 +9530,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_NAWK="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8549,15 +9546,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- NAWK=$ac_cv_path_NAWK
- if test -n "$NAWK"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
--$as_echo "$NAWK" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
-+printf "%s\n" "$NAWK" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8573,20 +9571,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xNAWK" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of NAWK from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in nawk gawk awk
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_NAWK+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $NAWK in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_NAWK+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $NAWK in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
-   ;;
-@@ -8595,11 +9594,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_NAWK="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8607,15 +9610,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- NAWK=$ac_cv_path_NAWK
- if test -n "$NAWK"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
--$as_echo "$NAWK" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
-+printf "%s\n" "$NAWK" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8635,16 +9639,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NAWK=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool NAWK=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_NAWK+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $NAWK in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_NAWK+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $NAWK in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_NAWK="$NAWK" # Let the user override the test with a path.
-   ;;
-@@ -8653,11 +9658,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_NAWK="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_NAWK="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8665,15 +9674,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- NAWK=$ac_cv_path_NAWK
- if test -n "$NAWK"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
--$as_echo "$NAWK" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NAWK" >&5
-+printf "%s\n" "$NAWK" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8682,17 +9692,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
--$as_echo_n "checking for NAWK... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NAWK=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool NAWK=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for NAWK" >&5
-+printf %s "checking for NAWK... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool NAWK=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -8716,12 +9726,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_PRINTF+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $PRINTF in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_PRINTF+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $PRINTF in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
-   ;;
-@@ -8730,11 +9741,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_PRINTF="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8742,15 +9757,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- PRINTF=$ac_cv_path_PRINTF
- if test -n "$PRINTF"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
--$as_echo "$PRINTF" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
-+printf "%s\n" "$PRINTF" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8766,20 +9782,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xPRINTF" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of PRINTF from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in printf
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_PRINTF+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $PRINTF in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_PRINTF+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $PRINTF in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
-   ;;
-@@ -8788,11 +9805,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_PRINTF="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8800,15 +9821,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- PRINTF=$ac_cv_path_PRINTF
- if test -n "$PRINTF"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
--$as_echo "$PRINTF" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
-+printf "%s\n" "$PRINTF" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8828,16 +9850,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PRINTF=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool PRINTF=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_PRINTF+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $PRINTF in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_PRINTF+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $PRINTF in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_PRINTF="$PRINTF" # Let the user override the test with a path.
-   ;;
-@@ -8846,11 +9869,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_PRINTF="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_PRINTF="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8858,15 +9885,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- PRINTF=$ac_cv_path_PRINTF
- if test -n "$PRINTF"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
--$as_echo "$PRINTF" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PRINTF" >&5
-+printf "%s\n" "$PRINTF" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8875,17 +9903,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
--$as_echo_n "checking for PRINTF... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PRINTF=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool PRINTF=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for PRINTF" >&5
-+printf %s "checking for PRINTF... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool PRINTF=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -8909,12 +9937,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_RM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $RM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_RM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $RM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_RM="$RM" # Let the user override the test with a path.
-   ;;
-@@ -8923,11 +9952,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_RM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8935,15 +9968,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- RM=$ac_cv_path_RM
- if test -n "$RM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
--$as_echo "$RM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
-+printf "%s\n" "$RM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -8959,20 +9993,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xRM" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of RM from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in rm
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_RM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $RM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_RM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $RM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_RM="$RM" # Let the user override the test with a path.
-   ;;
-@@ -8981,11 +10016,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_RM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -8993,15 +10032,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- RM=$ac_cv_path_RM
- if test -n "$RM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
--$as_echo "$RM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
-+printf "%s\n" "$RM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9021,16 +10061,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool RM=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool RM=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_RM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $RM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_RM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $RM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_RM="$RM" # Let the user override the test with a path.
-   ;;
-@@ -9039,11 +10080,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_RM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_RM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9051,15 +10096,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- RM=$ac_cv_path_RM
- if test -n "$RM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
--$as_echo "$RM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RM" >&5
-+printf "%s\n" "$RM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9068,17 +10114,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
--$as_echo_n "checking for RM... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool RM=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool RM=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for RM" >&5
-+printf %s "checking for RM... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool RM=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -9102,12 +10148,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_SH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $SH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_SH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $SH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_SH="$SH" # Let the user override the test with a path.
-   ;;
-@@ -9116,11 +10163,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_SH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9128,15 +10179,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- SH=$ac_cv_path_SH
- if test -n "$SH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
--$as_echo "$SH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
-+printf "%s\n" "$SH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9152,20 +10204,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xSH" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of SH from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in sh
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_SH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $SH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_SH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $SH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_SH="$SH" # Let the user override the test with a path.
-   ;;
-@@ -9174,11 +10227,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_SH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9186,15 +10243,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- SH=$ac_cv_path_SH
- if test -n "$SH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
--$as_echo "$SH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
-+printf "%s\n" "$SH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9214,16 +10272,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SH=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool SH=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_SH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $SH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_SH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $SH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_SH="$SH" # Let the user override the test with a path.
-   ;;
-@@ -9232,11 +10291,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_SH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_SH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9244,15 +10307,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- SH=$ac_cv_path_SH
- if test -n "$SH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
--$as_echo "$SH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SH" >&5
-+printf "%s\n" "$SH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9261,17 +10325,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
--$as_echo_n "checking for SH... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SH=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool SH=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for SH" >&5
-+printf %s "checking for SH... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool SH=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -9295,12 +10359,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_SORT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $SORT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_SORT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $SORT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
-   ;;
-@@ -9309,11 +10374,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_SORT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9321,15 +10390,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- SORT=$ac_cv_path_SORT
- if test -n "$SORT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
--$as_echo "$SORT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
-+printf "%s\n" "$SORT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9345,20 +10415,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xSORT" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of SORT from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in sort
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_SORT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $SORT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_SORT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $SORT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
-   ;;
-@@ -9367,11 +10438,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_SORT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9379,15 +10454,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- SORT=$ac_cv_path_SORT
- if test -n "$SORT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
--$as_echo "$SORT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
-+printf "%s\n" "$SORT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9407,16 +10483,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SORT=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool SORT=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_SORT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $SORT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_SORT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $SORT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_SORT="$SORT" # Let the user override the test with a path.
-   ;;
-@@ -9425,11 +10502,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_SORT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_SORT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9437,15 +10518,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- SORT=$ac_cv_path_SORT
- if test -n "$SORT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
--$as_echo "$SORT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SORT" >&5
-+printf "%s\n" "$SORT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9454,17 +10536,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
--$as_echo_n "checking for SORT... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SORT=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool SORT=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for SORT" >&5
-+printf %s "checking for SORT... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool SORT=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -9488,12 +10570,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TAIL+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TAIL in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TAIL+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TAIL in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
-   ;;
-@@ -9502,11 +10585,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TAIL="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9514,15 +10601,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TAIL=$ac_cv_path_TAIL
- if test -n "$TAIL"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
--$as_echo "$TAIL" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
-+printf "%s\n" "$TAIL" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9538,20 +10626,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xTAIL" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of TAIL from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in tail
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TAIL+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TAIL in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TAIL+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TAIL in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
-   ;;
-@@ -9560,11 +10649,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TAIL="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9572,15 +10665,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TAIL=$ac_cv_path_TAIL
- if test -n "$TAIL"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
--$as_echo "$TAIL" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
-+printf "%s\n" "$TAIL" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9600,16 +10694,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAIL=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool TAIL=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TAIL+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TAIL in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TAIL+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TAIL in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TAIL="$TAIL" # Let the user override the test with a path.
-   ;;
-@@ -9618,11 +10713,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TAIL="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TAIL="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9630,15 +10729,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TAIL=$ac_cv_path_TAIL
- if test -n "$TAIL"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
--$as_echo "$TAIL" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TAIL" >&5
-+printf "%s\n" "$TAIL" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9647,17 +10747,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
--$as_echo_n "checking for TAIL... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAIL=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool TAIL=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for TAIL" >&5
-+printf %s "checking for TAIL... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool TAIL=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -9681,12 +10781,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TAR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TAR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TAR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TAR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
-   ;;
-@@ -9695,11 +10796,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TAR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9707,15 +10812,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TAR=$ac_cv_path_TAR
- if test -n "$TAR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
--$as_echo "$TAR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
-+printf "%s\n" "$TAR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9731,20 +10837,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xTAR" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of TAR from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in tar
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TAR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TAR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TAR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TAR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
-   ;;
-@@ -9753,11 +10860,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TAR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9765,15 +10876,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TAR=$ac_cv_path_TAR
- if test -n "$TAR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
--$as_echo "$TAR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
-+printf "%s\n" "$TAR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9793,16 +10905,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TAR=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool TAR=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TAR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TAR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TAR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TAR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TAR="$TAR" # Let the user override the test with a path.
-   ;;
-@@ -9811,11 +10924,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TAR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TAR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9823,15 +10940,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TAR=$ac_cv_path_TAR
- if test -n "$TAR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
--$as_echo "$TAR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TAR" >&5
-+printf "%s\n" "$TAR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9840,17 +10958,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
--$as_echo_n "checking for TAR... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TAR=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool TAR=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for TAR" >&5
-+printf %s "checking for TAR... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool TAR=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -9874,12 +10992,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TEE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TEE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TEE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TEE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
-   ;;
-@@ -9888,11 +11007,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TEE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9900,15 +11023,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TEE=$ac_cv_path_TEE
- if test -n "$TEE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
--$as_echo "$TEE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
-+printf "%s\n" "$TEE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9924,20 +11048,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xTEE" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of TEE from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in tee
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TEE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TEE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TEE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TEE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
-   ;;
-@@ -9946,11 +11071,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TEE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -9958,15 +11087,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TEE=$ac_cv_path_TEE
- if test -n "$TEE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
--$as_echo "$TEE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
-+printf "%s\n" "$TEE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -9986,16 +11116,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TEE=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool TEE=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TEE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TEE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TEE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TEE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TEE="$TEE" # Let the user override the test with a path.
-   ;;
-@@ -10004,11 +11135,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TEE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TEE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10016,15 +11151,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TEE=$ac_cv_path_TEE
- if test -n "$TEE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
--$as_echo "$TEE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TEE" >&5
-+printf "%s\n" "$TEE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10033,17 +11169,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
--$as_echo_n "checking for TEE... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TEE=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool TEE=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for TEE" >&5
-+printf %s "checking for TEE... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool TEE=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -10067,12 +11203,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TOUCH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TOUCH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TOUCH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TOUCH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
-   ;;
-@@ -10081,11 +11218,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TOUCH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10093,15 +11234,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TOUCH=$ac_cv_path_TOUCH
- if test -n "$TOUCH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
--$as_echo "$TOUCH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
-+printf "%s\n" "$TOUCH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10117,20 +11259,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xTOUCH" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of TOUCH from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in touch
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TOUCH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TOUCH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TOUCH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TOUCH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
-   ;;
-@@ -10139,11 +11282,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TOUCH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10151,15 +11298,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TOUCH=$ac_cv_path_TOUCH
- if test -n "$TOUCH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
--$as_echo "$TOUCH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
-+printf "%s\n" "$TOUCH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10179,16 +11327,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TOUCH=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool TOUCH=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TOUCH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TOUCH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TOUCH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TOUCH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TOUCH="$TOUCH" # Let the user override the test with a path.
-   ;;
-@@ -10197,11 +11346,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TOUCH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TOUCH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10209,15 +11362,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TOUCH=$ac_cv_path_TOUCH
- if test -n "$TOUCH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
--$as_echo "$TOUCH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOUCH" >&5
-+printf "%s\n" "$TOUCH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10226,17 +11380,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
--$as_echo_n "checking for TOUCH... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TOUCH=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool TOUCH=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for TOUCH" >&5
-+printf %s "checking for TOUCH... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool TOUCH=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -10260,12 +11414,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TR="$TR" # Let the user override the test with a path.
-   ;;
-@@ -10274,11 +11429,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10286,15 +11445,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TR=$ac_cv_path_TR
- if test -n "$TR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
--$as_echo "$TR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
-+printf "%s\n" "$TR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10310,20 +11470,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xTR" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of TR from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in tr
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TR="$TR" # Let the user override the test with a path.
-   ;;
-@@ -10332,11 +11493,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10344,15 +11509,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TR=$ac_cv_path_TR
- if test -n "$TR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
--$as_echo "$TR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
-+printf "%s\n" "$TR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10372,16 +11538,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TR=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool TR=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TR="$TR" # Let the user override the test with a path.
-   ;;
-@@ -10390,11 +11557,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10402,15 +11573,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TR=$ac_cv_path_TR
- if test -n "$TR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
--$as_echo "$TR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TR" >&5
-+printf "%s\n" "$TR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10419,17 +11591,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
--$as_echo_n "checking for TR... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TR=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool TR=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for TR" >&5
-+printf %s "checking for TR... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool TR=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -10453,12 +11625,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_UNAME+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $UNAME in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_UNAME+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $UNAME in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
-   ;;
-@@ -10467,11 +11640,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_UNAME="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10479,15 +11656,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- UNAME=$ac_cv_path_UNAME
- if test -n "$UNAME"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
--$as_echo "$UNAME" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
-+printf "%s\n" "$UNAME" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10503,20 +11681,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xUNAME" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of UNAME from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in uname
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_UNAME+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $UNAME in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_UNAME+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $UNAME in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
-   ;;
-@@ -10525,11 +11704,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_UNAME="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10537,15 +11720,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- UNAME=$ac_cv_path_UNAME
- if test -n "$UNAME"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
--$as_echo "$UNAME" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
-+printf "%s\n" "$UNAME" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10565,16 +11749,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNAME=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool UNAME=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_UNAME+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $UNAME in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_UNAME+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $UNAME in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_UNAME="$UNAME" # Let the user override the test with a path.
-   ;;
-@@ -10583,11 +11768,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_UNAME="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_UNAME="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10595,15 +11784,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- UNAME=$ac_cv_path_UNAME
- if test -n "$UNAME"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
--$as_echo "$UNAME" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNAME" >&5
-+printf "%s\n" "$UNAME" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10612,17 +11802,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
--$as_echo_n "checking for UNAME... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNAME=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool UNAME=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for UNAME" >&5
-+printf %s "checking for UNAME... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool UNAME=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -10646,12 +11836,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_UNIQ+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $UNIQ in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_UNIQ+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $UNIQ in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
-   ;;
-@@ -10660,11 +11851,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_UNIQ="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10672,15 +11867,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- UNIQ=$ac_cv_path_UNIQ
- if test -n "$UNIQ"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
--$as_echo "$UNIQ" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
-+printf "%s\n" "$UNIQ" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10696,20 +11892,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xUNIQ" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of UNIQ from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in uniq
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_UNIQ+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $UNIQ in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_UNIQ+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $UNIQ in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
-   ;;
-@@ -10718,11 +11915,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_UNIQ="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10730,15 +11931,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- UNIQ=$ac_cv_path_UNIQ
- if test -n "$UNIQ"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
--$as_echo "$UNIQ" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
-+printf "%s\n" "$UNIQ" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10758,16 +11960,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNIQ=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool UNIQ=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_UNIQ+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $UNIQ in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_UNIQ+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $UNIQ in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_UNIQ="$UNIQ" # Let the user override the test with a path.
-   ;;
-@@ -10776,11 +11979,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_UNIQ="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_UNIQ="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10788,15 +11995,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- UNIQ=$ac_cv_path_UNIQ
- if test -n "$UNIQ"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
--$as_echo "$UNIQ" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNIQ" >&5
-+printf "%s\n" "$UNIQ" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10805,17 +12013,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
--$as_echo_n "checking for UNIQ... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNIQ=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool UNIQ=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for UNIQ" >&5
-+printf %s "checking for UNIQ... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool UNIQ=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -10839,12 +12047,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_WC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $WC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_WC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $WC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_WC="$WC" # Let the user override the test with a path.
-   ;;
-@@ -10853,11 +12062,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_WC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10865,15 +12078,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- WC=$ac_cv_path_WC
- if test -n "$WC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
--$as_echo "$WC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
-+printf "%s\n" "$WC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10889,20 +12103,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xWC" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of WC from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in wc
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_WC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $WC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_WC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $WC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_WC="$WC" # Let the user override the test with a path.
-   ;;
-@@ -10911,11 +12126,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_WC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10923,15 +12142,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- WC=$ac_cv_path_WC
- if test -n "$WC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
--$as_echo "$WC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
-+printf "%s\n" "$WC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10951,16 +12171,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WC=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool WC=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_WC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $WC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_WC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $WC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_WC="$WC" # Let the user override the test with a path.
-   ;;
-@@ -10969,11 +12190,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_WC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_WC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -10981,15 +12206,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- WC=$ac_cv_path_WC
- if test -n "$WC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
--$as_echo "$WC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WC" >&5
-+printf "%s\n" "$WC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -10998,17 +12224,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
--$as_echo_n "checking for WC... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WC=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool WC=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for WC" >&5
-+printf %s "checking for WC... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool WC=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -11032,12 +12258,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_WHICH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $WHICH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_WHICH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $WHICH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
-   ;;
-@@ -11046,11 +12273,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_WHICH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -11058,15 +12289,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- WHICH=$ac_cv_path_WHICH
- if test -n "$WHICH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
--$as_echo "$WHICH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
-+printf "%s\n" "$WHICH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -11082,20 +12314,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xWHICH" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of WHICH from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in which
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_WHICH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $WHICH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_WHICH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $WHICH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
-   ;;
-@@ -11104,11 +12337,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_WHICH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -11116,15 +12353,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- WHICH=$ac_cv_path_WHICH
- if test -n "$WHICH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
--$as_echo "$WHICH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
-+printf "%s\n" "$WHICH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -11144,16 +12382,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool WHICH=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool WHICH=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_WHICH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $WHICH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_WHICH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $WHICH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_WHICH="$WHICH" # Let the user override the test with a path.
-   ;;
-@@ -11162,11 +12401,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_WHICH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_WHICH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -11174,15 +12417,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- WHICH=$ac_cv_path_WHICH
- if test -n "$WHICH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
--$as_echo "$WHICH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $WHICH" >&5
-+printf "%s\n" "$WHICH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -11191,17 +12435,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
--$as_echo_n "checking for WHICH... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool WHICH=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool WHICH=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for WHICH" >&5
-+printf %s "checking for WHICH... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool WHICH=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -11225,12 +12469,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_XARGS+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $XARGS in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_XARGS+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $XARGS in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
-   ;;
-@@ -11239,11 +12484,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_XARGS="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -11251,15 +12500,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- XARGS=$ac_cv_path_XARGS
- if test -n "$XARGS"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
--$as_echo "$XARGS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
-+printf "%s\n" "$XARGS" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -11275,20 +12525,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xXARGS" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of XARGS from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in xargs
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_XARGS+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $XARGS in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_XARGS+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $XARGS in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
-   ;;
-@@ -11297,11 +12548,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_XARGS="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -11309,15 +12564,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- XARGS=$ac_cv_path_XARGS
- if test -n "$XARGS"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
--$as_echo "$XARGS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
-+printf "%s\n" "$XARGS" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -11337,16 +12593,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XARGS=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool XARGS=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_XARGS+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $XARGS in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_XARGS+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $XARGS in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_XARGS="$XARGS" # Let the user override the test with a path.
-   ;;
-@@ -11355,11 +12612,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_XARGS="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_XARGS="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -11367,15 +12628,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- XARGS=$ac_cv_path_XARGS
- if test -n "$XARGS"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
--$as_echo "$XARGS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XARGS" >&5
-+printf "%s\n" "$XARGS" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -11384,17 +12646,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
--$as_echo_n "checking for XARGS... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XARGS=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool XARGS=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for XARGS" >&5
-+printf %s "checking for XARGS... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool XARGS=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -11419,38 +12681,44 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_AWK+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$AWK"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_AWK+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$AWK"; then
-   ac_cv_prog_AWK="$AWK" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_AWK="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- AWK=$ac_cv_prog_AWK
- if test -n "$AWK"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
--$as_echo "$AWK" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
-+printf "%s\n" "$AWK" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -11466,46 +12734,52 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xAWK" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of AWK from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in gawk mawk nawk awk
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_AWK+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$AWK"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_AWK+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$AWK"; then
-   ac_cv_prog_AWK="$AWK" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_AWK="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- AWK=$ac_cv_prog_AWK
- if test -n "$AWK"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
--$as_echo "$AWK" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
-+printf "%s\n" "$AWK" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -11525,16 +12799,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AWK=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool AWK=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_AWK+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $AWK in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_AWK+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $AWK in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_AWK="$AWK" # Let the user override the test with a path.
-   ;;
-@@ -11543,11 +12818,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_AWK="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_AWK="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -11555,15 +12834,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- AWK=$ac_cv_path_AWK
- if test -n "$AWK"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
--$as_echo "$AWK" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
-+printf "%s\n" "$AWK" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -11572,17 +12852,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
--$as_echo_n "checking for AWK... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AWK=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool AWK=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for AWK" >&5
-+printf %s "checking for AWK... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool AWK=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -11600,37 +12880,44 @@ $as_echo "$tool_specified" >&6; }
- 
-   if test "x$GREP" = x; then
-     # The variable is not set by user, try to locate tool using the code snippet
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
--$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
--if ${ac_cv_path_GREP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -z "$GREP"; then
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
-+printf %s "checking for grep that handles long lines and -e... " >&6; }
-+if test ${ac_cv_path_GREP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -z "$GREP"; then
-   ac_path_GREP_found=false
-   # Loop through the user's path and test for each of PROGNAME-LIST
-   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
--    for ac_prog in grep ggrep; do
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-+    for ac_prog in grep ggrep
-+   do
-     for ac_exec_ext in '' $ac_executable_extensions; do
--      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
-+      ac_path_GREP="$as_dir$ac_prog$ac_exec_ext"
-       as_fn_executable_p "$ac_path_GREP" || continue
- # Check for GNU ac_path_GREP and select it if it is found.
-   # Check for GNU $ac_path_GREP
--case `"$ac_path_GREP" --version 2>&1` in
-+case `"$ac_path_GREP" --version 2>&1` in #(
- *GNU*)
-   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
-+#(
- *)
-   ac_count=0
--  $as_echo_n 0123456789 >"conftest.in"
-+  printf %s 0123456789 >"conftest.in"
-   while :
-   do
-     cat "conftest.in" "conftest.in" >"conftest.tmp"
-     mv "conftest.tmp" "conftest.in"
-     cp "conftest.in" "conftest.nl"
--    $as_echo 'GREP' >> "conftest.nl"
-+    printf "%s\n" 'GREP' >> "conftest.nl"
-     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
-     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-     as_fn_arith $ac_count + 1 && ac_count=$as_val
-@@ -11656,10 +12943,11 @@ IFS=$as_save_IFS
- else
-   ac_cv_path_GREP=$GREP
- fi
--
-+ ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
--$as_echo "$ac_cv_path_GREP" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
-+printf "%s\n" "$ac_cv_path_GREP" >&6; }
-  GREP="$ac_cv_path_GREP"
- 
- 
-@@ -11672,41 +12960,48 @@ $as_echo "$ac_cv_path_GREP" >&6; }
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xGREP" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of GREP from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
--$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
--if ${ac_cv_path_GREP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -z "$GREP"; then
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
-+printf %s "checking for grep that handles long lines and -e... " >&6; }
-+if test ${ac_cv_path_GREP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -z "$GREP"; then
-   ac_path_GREP_found=false
-   # Loop through the user's path and test for each of PROGNAME-LIST
-   as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
--    for ac_prog in grep ggrep; do
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-+    for ac_prog in grep ggrep
-+   do
-     for ac_exec_ext in '' $ac_executable_extensions; do
--      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
-+      ac_path_GREP="$as_dir$ac_prog$ac_exec_ext"
-       as_fn_executable_p "$ac_path_GREP" || continue
- # Check for GNU ac_path_GREP and select it if it is found.
-   # Check for GNU $ac_path_GREP
--case `"$ac_path_GREP" --version 2>&1` in
-+case `"$ac_path_GREP" --version 2>&1` in #(
- *GNU*)
-   ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
-+#(
- *)
-   ac_count=0
--  $as_echo_n 0123456789 >"conftest.in"
-+  printf %s 0123456789 >"conftest.in"
-   while :
-   do
-     cat "conftest.in" "conftest.in" >"conftest.tmp"
-     mv "conftest.tmp" "conftest.in"
-     cp "conftest.in" "conftest.nl"
--    $as_echo 'GREP' >> "conftest.nl"
-+    printf "%s\n" 'GREP' >> "conftest.nl"
-     "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
-     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-     as_fn_arith $ac_count + 1 && ac_count=$as_val
-@@ -11732,10 +13027,11 @@ IFS=$as_save_IFS
- else
-   ac_cv_path_GREP=$GREP
- fi
--
-+ ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
--$as_echo "$ac_cv_path_GREP" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
-+printf "%s\n" "$ac_cv_path_GREP" >&6; }
-  GREP="$ac_cv_path_GREP"
- 
- 
-@@ -11752,16 +13048,17 @@ $as_echo "$ac_cv_path_GREP" >&6; }
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GREP=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool GREP=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_GREP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $GREP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_GREP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $GREP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_GREP="$GREP" # Let the user override the test with a path.
-   ;;
-@@ -11770,11 +13067,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_GREP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_GREP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -11782,15 +13083,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- GREP=$ac_cv_path_GREP
- if test -n "$GREP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
--$as_echo "$GREP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GREP" >&5
-+printf "%s\n" "$GREP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -11799,17 +13101,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
--$as_echo_n "checking for GREP... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GREP=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool GREP=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GREP" >&5
-+printf %s "checking for GREP... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool GREP=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -11827,12 +13129,13 @@ $as_echo "$tool_specified" >&6; }
- 
-   if test "x$EGREP" = x; then
-     # The variable is not set by user, try to locate tool using the code snippet
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
--$as_echo_n "checking for egrep... " >&6; }
--if ${ac_cv_path_EGREP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
-+printf %s "checking for egrep... " >&6; }
-+if test ${ac_cv_path_EGREP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
-    then ac_cv_path_EGREP="$GREP -E"
-    else
-      if test -z "$EGREP"; then
-@@ -11842,25 +13145,31 @@ else
- for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
--    for ac_prog in egrep; do
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-+    for ac_prog in egrep
-+   do
-     for ac_exec_ext in '' $ac_executable_extensions; do
--      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
-+      ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext"
-       as_fn_executable_p "$ac_path_EGREP" || continue
- # Check for GNU ac_path_EGREP and select it if it is found.
-   # Check for GNU $ac_path_EGREP
--case `"$ac_path_EGREP" --version 2>&1` in
-+case `"$ac_path_EGREP" --version 2>&1` in #(
- *GNU*)
-   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
-+#(
- *)
-   ac_count=0
--  $as_echo_n 0123456789 >"conftest.in"
-+  printf %s 0123456789 >"conftest.in"
-   while :
-   do
-     cat "conftest.in" "conftest.in" >"conftest.tmp"
-     mv "conftest.tmp" "conftest.in"
-     cp "conftest.in" "conftest.nl"
--    $as_echo 'EGREP' >> "conftest.nl"
-+    printf "%s\n" 'EGREP' >> "conftest.nl"
-     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
-     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-     as_fn_arith $ac_count + 1 && ac_count=$as_val
-@@ -11887,12 +13196,15 @@ else
-   ac_cv_path_EGREP=$EGREP
- fi
- 
--   fi
-+   fi ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
--$as_echo "$ac_cv_path_EGREP" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
-+printf "%s\n" "$ac_cv_path_EGREP" >&6; }
-  EGREP="$ac_cv_path_EGREP"
- 
-+         EGREP_TRADITIONAL=$EGREP
-+ ac_cv_path_EGREP_TRADITIONAL=$EGREP
- 
-   else
-     # The variable is set, but is it from the command line or the environment?
-@@ -11903,16 +13215,17 @@ $as_echo "$ac_cv_path_EGREP" >&6; }
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xEGREP" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of EGREP from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
--$as_echo_n "checking for egrep... " >&6; }
--if ${ac_cv_path_EGREP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
-+printf %s "checking for egrep... " >&6; }
-+if test ${ac_cv_path_EGREP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
-    then ac_cv_path_EGREP="$GREP -E"
-    else
-      if test -z "$EGREP"; then
-@@ -11922,25 +13235,31 @@ else
- for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
--    for ac_prog in egrep; do
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-+    for ac_prog in egrep
-+   do
-     for ac_exec_ext in '' $ac_executable_extensions; do
--      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
-+      ac_path_EGREP="$as_dir$ac_prog$ac_exec_ext"
-       as_fn_executable_p "$ac_path_EGREP" || continue
- # Check for GNU ac_path_EGREP and select it if it is found.
-   # Check for GNU $ac_path_EGREP
--case `"$ac_path_EGREP" --version 2>&1` in
-+case `"$ac_path_EGREP" --version 2>&1` in #(
- *GNU*)
-   ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
-+#(
- *)
-   ac_count=0
--  $as_echo_n 0123456789 >"conftest.in"
-+  printf %s 0123456789 >"conftest.in"
-   while :
-   do
-     cat "conftest.in" "conftest.in" >"conftest.tmp"
-     mv "conftest.tmp" "conftest.in"
-     cp "conftest.in" "conftest.nl"
--    $as_echo 'EGREP' >> "conftest.nl"
-+    printf "%s\n" 'EGREP' >> "conftest.nl"
-     "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
-     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-     as_fn_arith $ac_count + 1 && ac_count=$as_val
-@@ -11967,12 +13286,15 @@ else
-   ac_cv_path_EGREP=$EGREP
- fi
- 
--   fi
-+   fi ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
--$as_echo "$ac_cv_path_EGREP" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
-+printf "%s\n" "$ac_cv_path_EGREP" >&6; }
-  EGREP="$ac_cv_path_EGREP"
- 
-+         EGREP_TRADITIONAL=$EGREP
-+ ac_cv_path_EGREP_TRADITIONAL=$EGREP
- 
-     else
-       # If it succeeded, then it was overridden by the user. We will use it
-@@ -11987,16 +13309,17 @@ $as_echo "$ac_cv_path_EGREP" >&6; }
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool EGREP=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool EGREP=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_EGREP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $EGREP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_EGREP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $EGREP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_EGREP="$EGREP" # Let the user override the test with a path.
-   ;;
-@@ -12005,11 +13328,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_EGREP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_EGREP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -12017,15 +13344,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- EGREP=$ac_cv_path_EGREP
- if test -n "$EGREP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
--$as_echo "$EGREP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $EGREP" >&5
-+printf "%s\n" "$EGREP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -12034,17 +13362,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
--$as_echo_n "checking for EGREP... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool EGREP=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool EGREP=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for EGREP" >&5
-+printf %s "checking for EGREP... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool EGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -12062,12 +13390,13 @@ $as_echo "$tool_specified" >&6; }
- 
-   if test "x$FGREP" = x; then
-     # The variable is not set by user, try to locate tool using the code snippet
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
--$as_echo_n "checking for fgrep... " >&6; }
--if ${ac_cv_path_FGREP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
-+printf %s "checking for fgrep... " >&6; }
-+if test ${ac_cv_path_FGREP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
-    then ac_cv_path_FGREP="$GREP -F"
-    else
-      if test -z "$FGREP"; then
-@@ -12077,25 +13406,31 @@ else
- for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
--    for ac_prog in fgrep; do
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-+    for ac_prog in fgrep
-+   do
-     for ac_exec_ext in '' $ac_executable_extensions; do
--      ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
-+      ac_path_FGREP="$as_dir$ac_prog$ac_exec_ext"
-       as_fn_executable_p "$ac_path_FGREP" || continue
- # Check for GNU ac_path_FGREP and select it if it is found.
-   # Check for GNU $ac_path_FGREP
--case `"$ac_path_FGREP" --version 2>&1` in
-+case `"$ac_path_FGREP" --version 2>&1` in #(
- *GNU*)
-   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
-+#(
- *)
-   ac_count=0
--  $as_echo_n 0123456789 >"conftest.in"
-+  printf %s 0123456789 >"conftest.in"
-   while :
-   do
-     cat "conftest.in" "conftest.in" >"conftest.tmp"
-     mv "conftest.tmp" "conftest.in"
-     cp "conftest.in" "conftest.nl"
--    $as_echo 'FGREP' >> "conftest.nl"
-+    printf "%s\n" 'FGREP' >> "conftest.nl"
-     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
-     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-     as_fn_arith $ac_count + 1 && ac_count=$as_val
-@@ -12122,10 +13457,11 @@ else
-   ac_cv_path_FGREP=$FGREP
- fi
- 
--   fi
-+   fi ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
--$as_echo "$ac_cv_path_FGREP" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
-+printf "%s\n" "$ac_cv_path_FGREP" >&6; }
-  FGREP="$ac_cv_path_FGREP"
- 
- 
-@@ -12138,16 +13474,17 @@ $as_echo "$ac_cv_path_FGREP" >&6; }
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xFGREP" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of FGREP from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
--$as_echo_n "checking for fgrep... " >&6; }
--if ${ac_cv_path_FGREP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
-+printf %s "checking for fgrep... " >&6; }
-+if test ${ac_cv_path_FGREP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
-    then ac_cv_path_FGREP="$GREP -F"
-    else
-      if test -z "$FGREP"; then
-@@ -12157,25 +13494,31 @@ else
- for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
--    for ac_prog in fgrep; do
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-+    for ac_prog in fgrep
-+   do
-     for ac_exec_ext in '' $ac_executable_extensions; do
--      ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
-+      ac_path_FGREP="$as_dir$ac_prog$ac_exec_ext"
-       as_fn_executable_p "$ac_path_FGREP" || continue
- # Check for GNU ac_path_FGREP and select it if it is found.
-   # Check for GNU $ac_path_FGREP
--case `"$ac_path_FGREP" --version 2>&1` in
-+case `"$ac_path_FGREP" --version 2>&1` in #(
- *GNU*)
-   ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
-+#(
- *)
-   ac_count=0
--  $as_echo_n 0123456789 >"conftest.in"
-+  printf %s 0123456789 >"conftest.in"
-   while :
-   do
-     cat "conftest.in" "conftest.in" >"conftest.tmp"
-     mv "conftest.tmp" "conftest.in"
-     cp "conftest.in" "conftest.nl"
--    $as_echo 'FGREP' >> "conftest.nl"
-+    printf "%s\n" 'FGREP' >> "conftest.nl"
-     "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
-     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-     as_fn_arith $ac_count + 1 && ac_count=$as_val
-@@ -12202,10 +13545,11 @@ else
-   ac_cv_path_FGREP=$FGREP
- fi
- 
--   fi
-+   fi ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
--$as_echo "$ac_cv_path_FGREP" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
-+printf "%s\n" "$ac_cv_path_FGREP" >&6; }
-  FGREP="$ac_cv_path_FGREP"
- 
- 
-@@ -12222,16 +13566,17 @@ $as_echo "$ac_cv_path_FGREP" >&6; }
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool FGREP=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool FGREP=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_FGREP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $FGREP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_FGREP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $FGREP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_FGREP="$FGREP" # Let the user override the test with a path.
-   ;;
-@@ -12240,11 +13585,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_FGREP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_FGREP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -12252,15 +13601,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- FGREP=$ac_cv_path_FGREP
- if test -n "$FGREP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
--$as_echo "$FGREP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FGREP" >&5
-+printf "%s\n" "$FGREP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -12269,17 +13619,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
--$as_echo_n "checking for FGREP... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool FGREP=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool FGREP=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for FGREP" >&5
-+printf %s "checking for FGREP... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool FGREP=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -12297,12 +13647,13 @@ $as_echo "$tool_specified" >&6; }
- 
-   if test "x$SED" = x; then
-     # The variable is not set by user, try to locate tool using the code snippet
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
--$as_echo_n "checking for a sed that does not truncate output... " >&6; }
--if ${ac_cv_path_SED+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
-+printf %s "checking for a sed that does not truncate output... " >&6; }
-+if test ${ac_cv_path_SED+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e)           ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
-      for ac_i in 1 2 3 4 5 6 7; do
-        ac_script="$ac_script$as_nl$ac_script"
-      done
-@@ -12315,25 +13666,31 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
--    for ac_prog in sed gsed; do
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-+    for ac_prog in sed gsed
-+   do
-     for ac_exec_ext in '' $ac_executable_extensions; do
--      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
-+      ac_path_SED="$as_dir$ac_prog$ac_exec_ext"
-       as_fn_executable_p "$ac_path_SED" || continue
- # Check for GNU ac_path_SED and select it if it is found.
-   # Check for GNU $ac_path_SED
--case `"$ac_path_SED" --version 2>&1` in
-+case `"$ac_path_SED" --version 2>&1` in #(
- *GNU*)
-   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
-+#(
- *)
-   ac_count=0
--  $as_echo_n 0123456789 >"conftest.in"
-+  printf %s 0123456789 >"conftest.in"
-   while :
-   do
-     cat "conftest.in" "conftest.in" >"conftest.tmp"
-     mv "conftest.tmp" "conftest.in"
-     cp "conftest.in" "conftest.nl"
--    $as_echo '' >> "conftest.nl"
-+    printf "%s\n" '' >> "conftest.nl"
-     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
-     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-     as_fn_arith $ac_count + 1 && ac_count=$as_val
-@@ -12359,10 +13716,11 @@ IFS=$as_save_IFS
- else
-   ac_cv_path_SED=$SED
- fi
--
-+ ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
--$as_echo "$ac_cv_path_SED" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
-+printf "%s\n" "$ac_cv_path_SED" >&6; }
-  SED="$ac_cv_path_SED"
-   rm -f conftest.sed
- 
-@@ -12375,16 +13733,17 @@ $as_echo "$ac_cv_path_SED" >&6; }
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xSED" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of SED from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
--$as_echo_n "checking for a sed that does not truncate output... " >&6; }
--if ${ac_cv_path_SED+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
-+printf %s "checking for a sed that does not truncate output... " >&6; }
-+if test ${ac_cv_path_SED+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e)           ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
-      for ac_i in 1 2 3 4 5 6 7; do
-        ac_script="$ac_script$as_nl$ac_script"
-      done
-@@ -12397,25 +13756,31 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
--    for ac_prog in sed gsed; do
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-+    for ac_prog in sed gsed
-+   do
-     for ac_exec_ext in '' $ac_executable_extensions; do
--      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
-+      ac_path_SED="$as_dir$ac_prog$ac_exec_ext"
-       as_fn_executable_p "$ac_path_SED" || continue
- # Check for GNU ac_path_SED and select it if it is found.
-   # Check for GNU $ac_path_SED
--case `"$ac_path_SED" --version 2>&1` in
-+case `"$ac_path_SED" --version 2>&1` in #(
- *GNU*)
-   ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
-+#(
- *)
-   ac_count=0
--  $as_echo_n 0123456789 >"conftest.in"
-+  printf %s 0123456789 >"conftest.in"
-   while :
-   do
-     cat "conftest.in" "conftest.in" >"conftest.tmp"
-     mv "conftest.tmp" "conftest.in"
-     cp "conftest.in" "conftest.nl"
--    $as_echo '' >> "conftest.nl"
-+    printf "%s\n" '' >> "conftest.nl"
-     "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
-     diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-     as_fn_arith $ac_count + 1 && ac_count=$as_val
-@@ -12441,10 +13806,11 @@ IFS=$as_save_IFS
- else
-   ac_cv_path_SED=$SED
- fi
--
-+ ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
--$as_echo "$ac_cv_path_SED" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
-+printf "%s\n" "$ac_cv_path_SED" >&6; }
-  SED="$ac_cv_path_SED"
-   rm -f conftest.sed
- 
-@@ -12461,16 +13827,17 @@ $as_echo "$ac_cv_path_SED" >&6; }
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SED=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool SED=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_SED+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $SED in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_SED+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $SED in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_SED="$SED" # Let the user override the test with a path.
-   ;;
-@@ -12479,11 +13846,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_SED="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_SED="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -12491,15 +13862,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- SED=$ac_cv_path_SED
- if test -n "$SED"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
--$as_echo "$SED" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SED" >&5
-+printf "%s\n" "$SED" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -12508,17 +13880,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
--$as_echo_n "checking for SED... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SED=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool SED=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for SED" >&5
-+printf %s "checking for SED... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool SED=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -12549,12 +13921,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CYGPATH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CYGPATH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CYGPATH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CYGPATH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
-   ;;
-@@ -12563,11 +13936,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CYGPATH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -12575,15 +13952,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CYGPATH=$ac_cv_path_CYGPATH
- if test -n "$CYGPATH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
--$as_echo "$CYGPATH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
-+printf "%s\n" "$CYGPATH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -12599,20 +13977,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xCYGPATH" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of CYGPATH from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in cygpath
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CYGPATH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CYGPATH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CYGPATH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CYGPATH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
-   ;;
-@@ -12621,11 +14000,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CYGPATH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -12633,15 +14016,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CYGPATH=$ac_cv_path_CYGPATH
- if test -n "$CYGPATH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
--$as_echo "$CYGPATH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
-+printf "%s\n" "$CYGPATH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -12661,16 +14045,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CYGPATH=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool CYGPATH=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CYGPATH+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CYGPATH in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CYGPATH+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CYGPATH in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CYGPATH="$CYGPATH" # Let the user override the test with a path.
-   ;;
-@@ -12679,11 +14064,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CYGPATH="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CYGPATH="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -12691,15 +14080,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CYGPATH=$ac_cv_path_CYGPATH
- if test -n "$CYGPATH"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
--$as_echo "$CYGPATH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
-+printf "%s\n" "$CYGPATH" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -12708,17 +14098,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
--$as_echo_n "checking for CYGPATH... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CYGPATH=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool CYGPATH=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CYGPATH" >&5
-+printf %s "checking for CYGPATH... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool CYGPATH=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -12735,12 +14125,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_READLINK+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $READLINK in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_READLINK+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $READLINK in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
-   ;;
-@@ -12749,11 +14140,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_READLINK="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -12761,15 +14156,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- READLINK=$ac_cv_path_READLINK
- if test -n "$READLINK"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
--$as_echo "$READLINK" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
-+printf "%s\n" "$READLINK" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -12785,20 +14181,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xREADLINK" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of READLINK from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in greadlink readlink
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_READLINK+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $READLINK in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_READLINK+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $READLINK in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
-   ;;
-@@ -12807,11 +14204,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_READLINK="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -12819,15 +14220,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- READLINK=$ac_cv_path_READLINK
- if test -n "$READLINK"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
--$as_echo "$READLINK" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
-+printf "%s\n" "$READLINK" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -12847,16 +14249,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READLINK=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool READLINK=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_READLINK+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $READLINK in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_READLINK+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $READLINK in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_READLINK="$READLINK" # Let the user override the test with a path.
-   ;;
-@@ -12865,11 +14268,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_READLINK="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_READLINK="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -12877,15 +14284,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- READLINK=$ac_cv_path_READLINK
- if test -n "$READLINK"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
--$as_echo "$READLINK" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $READLINK" >&5
-+printf "%s\n" "$READLINK" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -12894,17 +14302,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
--$as_echo_n "checking for READLINK... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READLINK=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool READLINK=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for READLINK" >&5
-+printf %s "checking for READLINK... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool READLINK=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -12921,12 +14329,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DF+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DF in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DF+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DF in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DF="$DF" # Let the user override the test with a path.
-   ;;
-@@ -12935,11 +14344,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DF="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -12947,15 +14360,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DF=$ac_cv_path_DF
- if test -n "$DF"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
--$as_echo "$DF" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
-+printf "%s\n" "$DF" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -12971,20 +14385,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xDF" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of DF from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in df
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DF+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DF in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DF+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DF in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DF="$DF" # Let the user override the test with a path.
-   ;;
-@@ -12993,11 +14408,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DF="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -13005,15 +14424,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DF=$ac_cv_path_DF
- if test -n "$DF"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
--$as_echo "$DF" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
-+printf "%s\n" "$DF" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -13033,16 +14453,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DF=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool DF=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DF+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DF in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DF+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DF in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DF="$DF" # Let the user override the test with a path.
-   ;;
-@@ -13051,11 +14472,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DF="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DF="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -13063,15 +14488,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DF=$ac_cv_path_DF
- if test -n "$DF"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
--$as_echo "$DF" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DF" >&5
-+printf "%s\n" "$DF" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -13080,17 +14506,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
--$as_echo_n "checking for DF... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DF=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool DF=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for DF" >&5
-+printf %s "checking for DF... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool DF=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -13107,12 +14533,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_SETFILE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $SETFILE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_SETFILE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $SETFILE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
-   ;;
-@@ -13121,11 +14548,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_SETFILE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -13133,15 +14564,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- SETFILE=$ac_cv_path_SETFILE
- if test -n "$SETFILE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
--$as_echo "$SETFILE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
-+printf "%s\n" "$SETFILE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -13157,20 +14589,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xSETFILE" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of SETFILE from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in SetFile
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_SETFILE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $SETFILE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_SETFILE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $SETFILE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
-   ;;
-@@ -13179,11 +14612,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_SETFILE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -13191,15 +14628,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- SETFILE=$ac_cv_path_SETFILE
- if test -n "$SETFILE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
--$as_echo "$SETFILE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
-+printf "%s\n" "$SETFILE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -13219,16 +14657,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool SETFILE=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool SETFILE=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_SETFILE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $SETFILE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_SETFILE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $SETFILE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_SETFILE="$SETFILE" # Let the user override the test with a path.
-   ;;
-@@ -13237,11 +14676,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_SETFILE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_SETFILE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -13249,15 +14692,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- SETFILE=$ac_cv_path_SETFILE
- if test -n "$SETFILE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
--$as_echo "$SETFILE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SETFILE" >&5
-+printf "%s\n" "$SETFILE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -13266,17 +14710,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
--$as_echo_n "checking for SETFILE... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool SETFILE=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool SETFILE=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for SETFILE" >&5
-+printf %s "checking for SETFILE... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool SETFILE=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -13293,12 +14737,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CPIO+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CPIO in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CPIO+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CPIO in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
-   ;;
-@@ -13307,11 +14752,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CPIO="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -13319,15 +14768,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CPIO=$ac_cv_path_CPIO
- if test -n "$CPIO"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
--$as_echo "$CPIO" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
-+printf "%s\n" "$CPIO" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -13343,20 +14793,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xCPIO" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of CPIO from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in cpio bsdcpio
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CPIO+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CPIO in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CPIO+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CPIO in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
-   ;;
-@@ -13365,11 +14816,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CPIO="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -13377,15 +14832,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CPIO=$ac_cv_path_CPIO
- if test -n "$CPIO"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
--$as_echo "$CPIO" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
-+printf "%s\n" "$CPIO" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -13405,16 +14861,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CPIO=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool CPIO=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CPIO+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CPIO in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CPIO+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CPIO in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CPIO="$CPIO" # Let the user override the test with a path.
-   ;;
-@@ -13423,11 +14880,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CPIO="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CPIO="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -13435,15 +14896,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CPIO=$ac_cv_path_CPIO
- if test -n "$CPIO"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
--$as_echo "$CPIO" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPIO" >&5
-+printf "%s\n" "$CPIO" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -13452,17 +14914,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
--$as_echo_n "checking for CPIO... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CPIO=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool CPIO=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CPIO" >&5
-+printf %s "checking for CPIO... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool CPIO=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -13479,12 +14941,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_PANDOC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $PANDOC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_PANDOC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $PANDOC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_PANDOC="$PANDOC" # Let the user override the test with a path.
-   ;;
-@@ -13493,11 +14956,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_PANDOC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_PANDOC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -13505,15 +14972,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- PANDOC=$ac_cv_path_PANDOC
- if test -n "$PANDOC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
--$as_echo "$PANDOC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
-+printf "%s\n" "$PANDOC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -13529,20 +14997,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xPANDOC" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PANDOC from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of PANDOC from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of PANDOC from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of PANDOC from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in pandoc
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_PANDOC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $PANDOC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_PANDOC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $PANDOC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_PANDOC="$PANDOC" # Let the user override the test with a path.
-   ;;
-@@ -13551,11 +15020,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_PANDOC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_PANDOC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -13563,15 +15036,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- PANDOC=$ac_cv_path_PANDOC
- if test -n "$PANDOC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
--$as_echo "$PANDOC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
-+printf "%s\n" "$PANDOC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -13591,16 +15065,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PANDOC=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool PANDOC=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool PANDOC=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool PANDOC=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_PANDOC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $PANDOC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_PANDOC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $PANDOC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_PANDOC="$PANDOC" # Let the user override the test with a path.
-   ;;
-@@ -13609,11 +15084,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_PANDOC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_PANDOC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -13621,15 +15100,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- PANDOC=$ac_cv_path_PANDOC
- if test -n "$PANDOC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
--$as_echo "$PANDOC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PANDOC" >&5
-+printf "%s\n" "$PANDOC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -13638,17 +15118,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PANDOC=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool PANDOC=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for PANDOC" >&5
--$as_echo_n "checking for PANDOC... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool PANDOC=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool PANDOC=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for PANDOC" >&5
-+printf %s "checking for PANDOC... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool PANDOC=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -13658,26 +15138,31 @@ $as_echo "$tool_specified" >&6; }
- 
- # Now we can determine OpenJDK build and target platforms. This is required to
- # have early on.
--# Make sure we can run config.sub.
--$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
--  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
- 
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
--$as_echo_n "checking build system type... " >&6; }
--if ${ac_cv_build+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_build_alias=$build_alias
-+
-+
-+  # Make sure we can run config.sub.
-+$SHELL "${ac_aux_dir}config.sub" sun4 >/dev/null 2>&1 ||
-+  as_fn_error $? "cannot run $SHELL ${ac_aux_dir}config.sub" "$LINENO" 5
-+
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
-+printf %s "checking build system type... " >&6; }
-+if test ${ac_cv_build+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_build_alias=$build_alias
- test "x$ac_build_alias" = x &&
--  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
-+  ac_build_alias=`$SHELL "${ac_aux_dir}config.guess"`
- test "x$ac_build_alias" = x &&
-   as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
--ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
--  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
--
-+ac_cv_build=`$SHELL "${ac_aux_dir}config.sub" $ac_build_alias` ||
-+  as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $ac_build_alias failed" "$LINENO" 5
-+ ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
--$as_echo "$ac_cv_build" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
-+printf "%s\n" "$ac_cv_build" >&6; }
- case $ac_cv_build in
- *-*-*) ;;
- *) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
-@@ -13696,21 +15181,23 @@ IFS=$ac_save_IFS
- case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
- 
- 
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
--$as_echo_n "checking host system type... " >&6; }
--if ${ac_cv_host+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test "x$host_alias" = x; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
-+printf %s "checking host system type... " >&6; }
-+if test ${ac_cv_host+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test "x$host_alias" = x; then
-   ac_cv_host=$ac_cv_build
- else
--  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
--    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
-+  ac_cv_host=`$SHELL "${ac_aux_dir}config.sub" $host_alias` ||
-+    as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $host_alias failed" "$LINENO" 5
- fi
--
-+ ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
--$as_echo "$ac_cv_host" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
-+printf "%s\n" "$ac_cv_host" >&6; }
- case $ac_cv_host in
- *-*-*) ;;
- *) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
-@@ -13729,21 +15216,23 @@ IFS=$ac_save_IFS
- case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
- 
- 
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
--$as_echo_n "checking target system type... " >&6; }
--if ${ac_cv_target+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test "x$target_alias" = x; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking target system type" >&5
-+printf %s "checking target system type... " >&6; }
-+if test ${ac_cv_target+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test "x$target_alias" = x; then
-   ac_cv_target=$ac_cv_host
- else
--  ac_cv_target=`$SHELL "$ac_aux_dir/config.sub" $target_alias` ||
--    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $target_alias failed" "$LINENO" 5
-+  ac_cv_target=`$SHELL "${ac_aux_dir}config.sub" $target_alias` ||
-+    as_fn_error $? "$SHELL ${ac_aux_dir}config.sub $target_alias failed" "$LINENO" 5
- fi
--
-+ ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
--$as_echo "$ac_cv_target" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_target" >&5
-+printf "%s\n" "$ac_cv_target" >&6; }
- case $ac_cv_target in
- *-*-*) ;;
- *) as_fn_error $? "invalid value of canonical target" "$LINENO" 5;;
-@@ -13788,7 +15277,7 @@ test -n "$target_alias" &&
- 
- 
- 
--  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
-+  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
- 
-   case "$build_os" in
-     *linux*)
-@@ -13917,6 +15406,19 @@ test -n "$target_alias" &&
-       ;;
-   esac
- 
-+
-+  case "$build_os" in
-+    *linux*-musl)
-+      VAR_LIBC=musl
-+      ;;
-+    *linux*-gnu)
-+      VAR_LIBC=gnu
-+      ;;
-+    *)
-+      VAR_LIBC=default
-+      ;;
-+  esac
-+
-   # ..and setup our own variables. (Do this explicitely to facilitate searching)
-   OPENJDK_BUILD_OS="$VAR_OS"
-   OPENJDK_BUILD_OS_API="$VAR_OS_API"
-@@ -13925,6 +15427,9 @@ test -n "$target_alias" &&
-   OPENJDK_BUILD_CPU_ARCH="$VAR_CPU_ARCH"
-   OPENJDK_BUILD_CPU_BITS="$VAR_CPU_BITS"
-   OPENJDK_BUILD_CPU_ENDIAN="$VAR_CPU_ENDIAN"
-+  OPENJDK_BUILD_LIBC="$VAR_LIBC"
-+
-+
- 
- 
- 
-@@ -13932,13 +15437,19 @@ test -n "$target_alias" &&
- 
- 
- 
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
-+printf %s "checking openjdk-build os-cpu... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
-+printf "%s\n" "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-build os-cpu" >&5
--$as_echo_n "checking openjdk-build os-cpu... " >&6; }
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&5
--$as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
-+  if test "x$OPENJDK_BUILD_OS" = "xlinux"; then
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking openjdk-build C library" >&5
-+printf %s "checking openjdk-build C library... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_BUILD_LIBC" >&5
-+printf "%s\n" "$OPENJDK_BUILD_LIBC" >&6; }
-+  fi
- 
--  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU variables.
-+  # Convert the autoconf OS/CPU value to our own data, into the VAR_OS/CPU/LIBC variables.
- 
-   case "$host_os" in
-     *linux*)
-@@ -14067,6 +15578,19 @@ $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
-       ;;
-   esac
- 
-+
-+  case "$host_os" in
-+    *linux*-musl)
-+      VAR_LIBC=musl
-+      ;;
-+    *linux*-gnu)
-+      VAR_LIBC=gnu
-+      ;;
-+    *)
-+      VAR_LIBC=default
-+      ;;
-+  esac
-+
-   # ... and setup our own variables. (Do this explicitely to facilitate searching)
-   OPENJDK_TARGET_OS="$VAR_OS"
-   OPENJDK_TARGET_OS_API="$VAR_OS_API"
-@@ -14075,6 +15599,8 @@ $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
-   OPENJDK_TARGET_CPU_ARCH="$VAR_CPU_ARCH"
-   OPENJDK_TARGET_CPU_BITS="$VAR_CPU_BITS"
-   OPENJDK_TARGET_CPU_ENDIAN="$VAR_CPU_ENDIAN"
-+  OPENJDK_TARGET_LIBC="$VAR_LIBC"
-+
- 
- 
- 
-@@ -14083,15 +15609,23 @@ $as_echo "$OPENJDK_BUILD_OS-$OPENJDK_BUILD_CPU" >&6; }
- 
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
--$as_echo_n "checking openjdk-target os-cpu... " >&6; }
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
--$as_echo "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking openjdk-target os-cpu" >&5
-+printf %s "checking openjdk-target os-cpu... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&5
-+printf "%s\n" "$OPENJDK_TARGET_OS-$OPENJDK_TARGET_CPU" >&6; }
-+
-+  if test "x$OPENJDK_TARGET_OS" = "xlinux"; then
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking openjdk-target C library" >&5
-+printf %s "checking openjdk-target C library... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_LIBC" >&5
-+printf "%s\n" "$OPENJDK_TARGET_LIBC" >&6; }
-+  fi
- 
- 
- 
- # Check whether --with-target-bits was given.
--if test "${with_target_bits+set}" = set; then :
-+if test ${with_target_bits+y}
-+then :
-   withval=$with_target_bits;
- fi
- 
-@@ -14127,18 +15661,18 @@ fi
-     elif test "x$with_target_bits" = x64 && test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
-       as_fn_error $? "It is not possible to use --with-target-bits=64 on a 32 bit system. Use proper cross-compilation instead." "$LINENO" 5
-     elif test "x$with_target_bits" = "x$OPENJDK_TARGET_CPU_BITS"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
--$as_echo "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: --with-target-bits are set to build platform address size; argument has no meaning" >&5
-+printf "%s\n" "$as_me: --with-target-bits are set to build platform address size; argument has no meaning" >&6;}
-     else
-       as_fn_error $? "--with-target-bits can only be 32 or 64, you specified $with_target_bits!" "$LINENO" 5
-     fi
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
--$as_echo_n "checking compilation type... " >&6; }
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
--$as_echo "$COMPILE_TYPE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking compilation type" >&5
-+printf %s "checking compilation type... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMPILE_TYPE" >&5
-+printf "%s\n" "$COMPILE_TYPE" >&6; }
- 
- 
-   if test "x$OPENJDK_TARGET_OS" = "xsolaris"; then
-@@ -14303,48 +15837,48 @@ $as_echo "$COMPILE_TYPE" >&6; }
-   fi
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
--$as_echo_n "checking cygwin release... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking cygwin release" >&5
-+printf %s "checking cygwin release... " >&6; }
-     CYGWIN_VERSION=`$UNAME -r`
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
--$as_echo "$CYGWIN_VERSION" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_VERSION" >&5
-+printf "%s\n" "$CYGWIN_VERSION" >&6; }
-     WINDOWS_ENV_VENDOR='cygwin'
-     WINDOWS_ENV_VERSION="$CYGWIN_VERSION"
- 
-     CYGWIN_VERSION_OLD=`$ECHO $CYGWIN_VERSION | $GREP -e '^1\.0-6'`
-     if test "x$CYGWIN_VERSION_OLD" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&5
--$as_echo "$as_me: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&5
-+printf "%s\n" "$as_me: Your cygwin is too old. You are running $CYGWIN_VERSION, but at least cygwin 1.7 is required. Please upgrade." >&6;}
-       as_fn_error $? "Cannot continue" "$LINENO" 5
-     fi
-     if test "x$CYGPATH" = x; then
-       as_fn_error $? "Something is wrong with your cygwin installation since I cannot find cygpath.exe in your path" "$LINENO" 5
-     fi
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
--$as_echo_n "checking cygwin root directory as unix-style path... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking cygwin root directory as unix-style path" >&5
-+printf %s "checking cygwin root directory as unix-style path... " >&6; }
-     # The cmd output ends with Windows line endings (CR/LF)
-     cygwin_winpath_root=`cd / ; cmd /c cd | $TR -d '\r\n'`
-     # Force cygpath to report the proper root by including a trailing space, and then stripping it off again.
-     CYGWIN_ROOT_PATH=`$CYGPATH -u "$cygwin_winpath_root " | $CUT -f 1 -d " "`
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
--$as_echo "$CYGWIN_ROOT_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_ROOT_PATH" >&5
-+printf "%s\n" "$CYGWIN_ROOT_PATH" >&6; }
-     WINDOWS_ENV_ROOT_PATH="$CYGWIN_ROOT_PATH"
-     test_cygdrive_prefix=`$ECHO $CYGWIN_ROOT_PATH | $GREP ^/cygdrive/`
-     if test "x$test_cygdrive_prefix" = x; then
-       as_fn_error $? "Your cygdrive prefix is not /cygdrive. This is currently not supported. Change with mount -c." "$LINENO" 5
-     fi
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
--$as_echo_n "checking msys release... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking msys release" >&5
-+printf %s "checking msys release... " >&6; }
-     MSYS_VERSION=`$UNAME -r`
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
--$as_echo "$MSYS_VERSION" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSYS_VERSION" >&5
-+printf "%s\n" "$MSYS_VERSION" >&6; }
- 
-     WINDOWS_ENV_VENDOR='msys'
-     WINDOWS_ENV_VERSION="$MSYS_VERSION"
- 
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
--$as_echo_n "checking msys root directory as unix-style path... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking msys root directory as unix-style path" >&5
-+printf %s "checking msys root directory as unix-style path... " >&6; }
-     # The cmd output ends with Windows line endings (CR/LF), the grep command will strip that away
-     MSYS_ROOT_PATH=`cd / ; cmd /c cd | grep ".*"`
- 
-@@ -14357,33 +15891,33 @@ $as_echo_n "checking msys root directory as unix-style path... " >&6; }
-     MSYS_ROOT_PATH="$unix_path"
-   fi
- 
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
--$as_echo "$MSYS_ROOT_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSYS_ROOT_PATH" >&5
-+printf "%s\n" "$MSYS_ROOT_PATH" >&6; }
-     WINDOWS_ENV_ROOT_PATH="$MSYS_ROOT_PATH"
-   else
-     as_fn_error $? "Unknown Windows environment. Neither cygwin nor msys was detected." "$LINENO" 5
-   fi
- 
-   # Test if windows or unix (cygwin/msys) find is first in path.
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
--$as_echo_n "checking what kind of 'find' is first on the PATH... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what kind of 'find' is first on the PATH" >&5
-+printf %s "checking what kind of 'find' is first on the PATH... " >&6; }
-   FIND_BINARY_OUTPUT=`find --version 2>&1`
-   if test "x`echo $FIND_BINARY_OUTPUT | $GREP GNU`" != x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
--$as_echo "unix style" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unix style" >&5
-+printf "%s\n" "unix style" >&6; }
-   elif test "x`echo $FIND_BINARY_OUTPUT | $GREP FIND`" != x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
--$as_echo "Windows" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
--$as_echo "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
--    { $as_echo "$as_me:${as_lineno-$LINENO}: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&5
--$as_echo "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: Windows" >&5
-+printf "%s\n" "Windows" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&5
-+printf "%s\n" "$as_me: Your path contains Windows tools (C:\Windows\system32) before your unix (cygwin or msys) tools." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&5
-+printf "%s\n" "$as_me: This will not work. Please correct and make sure /usr/bin (or similar) is first in path." >&6;}
-     as_fn_error $? "Cannot continue" "$LINENO" 5
-   else
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
--$as_echo "unknown" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
--$as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
-+printf "%s\n" "unknown" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: It seems that your find utility is non-standard." >&5
-+printf "%s\n" "$as_me: WARNING: It seems that your find utility is non-standard." >&2;}
-   fi
- 
-   else
-@@ -14392,10 +15926,10 @@ $as_echo "$as_me: WARNING: It seems that your find utility is non-standard." >&2
- 
- 
-   # We get the top-level directory from the supporting wrappers.
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
--$as_echo_n "checking for top-level directory... " >&6; }
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
--$as_echo "$TOPDIR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for top-level directory" >&5
-+printf %s "checking for top-level directory... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOPDIR" >&5
-+printf "%s\n" "$TOPDIR" >&6; }
- 
- 
-   # We can only call BASIC_FIXUP_PATH after BASIC_CHECK_PATHS_WINDOWS.
-@@ -14419,8 +15953,8 @@ $as_echo "$TOPDIR" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of CURDIR" "$LINENO" 5
-   fi
- 
-@@ -14468,8 +16002,8 @@ $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid."
- 
-   if test "x$path" != "x$new_path"; then
-     CURDIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -14506,8 +16040,8 @@ $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     CURDIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CURDIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -14518,8 +16052,8 @@ $as_echo "$as_me: Rewriting CURDIR to \"$new_path\"" >&6;}
-     path="$CURDIR"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CURDIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -14552,8 +16086,8 @@ $as_echo "$as_me: The path of CURDIR, which resolves as \"$path\", is invalid."
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of TOPDIR" "$LINENO" 5
-   fi
- 
-@@ -14601,8 +16135,8 @@ $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid."
- 
-   if test "x$path" != "x$new_path"; then
-     TOPDIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -14639,8 +16173,8 @@ $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     TOPDIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting TOPDIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -14651,8 +16185,8 @@ $as_echo "$as_me: Rewriting TOPDIR to \"$new_path\"" >&6;}
-     path="$TOPDIR"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of TOPDIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -14684,34 +16218,36 @@ $as_echo "$as_me: The path of TOPDIR, which resolves as \"$path\", is invalid."
- # Check if it's a pure open build or if custom sources are to be used.
- 
-   # Check whether --enable-openjdk-only was given.
--if test "${enable_openjdk_only+set}" = set; then :
-+if test ${enable_openjdk_only+y}
-+then :
-   enableval=$enable_openjdk_only;
--else
--  enable_openjdk_only="no"
-+else case e in #(
-+  e) enable_openjdk_only="no" ;;
-+esac
- fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
--$as_echo_n "checking for presence of closed sources... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for presence of closed sources" >&5
-+printf %s "checking for presence of closed sources... " >&6; }
-   if test -d "$SRC_ROOT/jdk/src/closed"; then
-     CLOSED_SOURCE_PRESENT=yes
-   else
-     CLOSED_SOURCE_PRESENT=no
-   fi
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
--$as_echo "$CLOSED_SOURCE_PRESENT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CLOSED_SOURCE_PRESENT" >&5
-+printf "%s\n" "$CLOSED_SOURCE_PRESENT" >&6; }
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
--$as_echo_n "checking if closed source is suppressed (openjdk-only)... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if closed source is suppressed (openjdk-only)" >&5
-+printf %s "checking if closed source is suppressed (openjdk-only)... " >&6; }
-   SUPPRESS_CLOSED_SOURCE="$enable_openjdk_only"
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
--$as_echo "$SUPPRESS_CLOSED_SOURCE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SUPPRESS_CLOSED_SOURCE" >&5
-+printf "%s\n" "$SUPPRESS_CLOSED_SOURCE" >&6; }
- 
-   if test "x$CLOSED_SOURCE_PRESENT" = xno; then
-     OPENJDK=true
-     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
--$as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&5
-+printf "%s\n" "$as_me: WARNING: No closed source present, --enable-openjdk-only makes no sense" >&2;}
-     fi
-   else
-     if test "x$SUPPRESS_CLOSED_SOURCE" = "xyes"; then
-@@ -14741,11 +16277,12 @@ $as_echo "$as_me: WARNING: No closed source present, --enable-openjdk-only makes
-   # modules to compile into the JDK. In the future, these modules
-   # might even be Jigsaw modules.
-   #
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
--$as_echo_n "checking which variant of the JDK to build... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which variant of the JDK to build" >&5
-+printf %s "checking which variant of the JDK to build... " >&6; }
- 
- # Check whether --with-jdk-variant was given.
--if test "${with_jdk_variant+set}" = set; then :
-+if test ${with_jdk_variant+y}
-+then :
-   withval=$with_jdk_variant;
- fi
- 
-@@ -14758,8 +16295,8 @@ fi
- 
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
--$as_echo "$JDK_VARIANT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JDK_VARIANT" >&5
-+printf "%s\n" "$JDK_VARIANT" >&6; }
- 
- 
- ###############################################################################
-@@ -14768,11 +16305,12 @@ $as_echo "$JDK_VARIANT" >&6; }
- # Currently we have:
- #    template: Template interpreter (the default)
- #    cpp     : C++ interpreter
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
--$as_echo_n "checking which interpreter of the JVM to build... " >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which interpreter of the JVM to build" >&5
-+printf %s "checking which interpreter of the JVM to build... " >&6; }
- 
- # Check whether --with-jvm-interpreter was given.
--if test "${with_jvm_interpreter+set}" = set; then :
-+if test ${with_jvm_interpreter+y}
-+then :
-   withval=$with_jvm_interpreter;
- fi
- 
-@@ -14789,8 +16327,8 @@ fi
- 
- 
- 
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
--$as_echo "$with_jvm_interpreter" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_jvm_interpreter" >&5
-+printf "%s\n" "$with_jvm_interpreter" >&6; }
- 
- 
- 
-@@ -14806,11 +16344,12 @@ $as_echo "$with_jvm_interpreter" >&6; }
-   #    zero: no machine code interpreter, no compiler
-   #    zeroshark: zero interpreter and shark/llvm compiler backend
- #    core: interpreter only, no compiler (only works on some platforms)
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
--$as_echo_n "checking which variants of the JVM to build... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which variants of the JVM to build" >&5
-+printf %s "checking which variants of the JVM to build... " >&6; }
- 
- # Check whether --with-jvm-variants was given.
--if test "${with_jvm_variants+set}" = set; then :
-+if test ${with_jvm_variants+y}
-+then :
-   withval=$with_jvm_variants;
- fi
- 
-@@ -14825,8 +16364,8 @@ fi
-   if test "x$TEST_VARIANTS" != "x,"; then
-      as_fn_error $? "The available JVM variants are: server, client, minimal1, kernel, zero, zeroshark, core" "$LINENO" 5
-   fi
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
--$as_echo "$with_jvm_variants" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_jvm_variants" >&5
-+printf "%s\n" "$with_jvm_variants" >&6; }
- 
-   JVM_VARIANT_SERVER=`$ECHO "$JVM_VARIANTS" | $SED -e '/,server,/!s/.*/false/g' -e '/,server,/s/.*/true/g'`
-   JVM_VARIANT_CLIENT=`$ECHO "$JVM_VARIANTS" | $SED -e '/,client,/!s/.*/false/g' -e '/,client,/s/.*/true/g'`
-@@ -14871,6 +16410,9 @@ $as_echo "$with_jvm_variants" >&6; }
- 
- 
-   INCLUDE_SA=true
-+  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
-+    INCLUDE_SA=false
-+  fi
-   if test "x$JVM_VARIANT_ZERO" = xtrue ; then
-     INCLUDE_SA=false
-   fi
-@@ -14897,22 +16439,25 @@ $as_echo "$with_jvm_variants" >&6; }
-   #    slowdebug: debug information (-g), no optimizations, all asserts
-   #
-   DEBUG_LEVEL="release"
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
--$as_echo_n "checking which debug level to use... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking which debug level to use" >&5
-+printf %s "checking which debug level to use... " >&6; }
-   # Check whether --enable-debug was given.
--if test "${enable_debug+set}" = set; then :
-+if test ${enable_debug+y}
-+then :
-   enableval=$enable_debug;
-         ENABLE_DEBUG="${enableval}"
-         DEBUG_LEVEL="fastdebug"
- 
--else
--  ENABLE_DEBUG="no"
-+else case e in #(
-+  e) ENABLE_DEBUG="no" ;;
-+esac
- fi
- 
- 
- 
- # Check whether --with-debug-level was given.
--if test "${with_debug_level+set}" = set; then :
-+if test ${with_debug_level+y}
-+then :
-   withval=$with_debug_level;
-         DEBUG_LEVEL="${withval}"
-         if test "x$ENABLE_DEBUG" = xyes; then
-@@ -14921,8 +16466,8 @@ if test "${with_debug_level+set}" = set; then :
- 
- fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
--$as_echo "$DEBUG_LEVEL" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DEBUG_LEVEL" >&5
-+printf "%s\n" "$DEBUG_LEVEL" >&6; }
- 
-   if test "x$DEBUG_LEVEL" != xrelease && \
-       test "x$DEBUG_LEVEL" != xfastdebug && \
-@@ -15025,7 +16570,8 @@ $as_echo "$DEBUG_LEVEL" >&6; }
- 
- 
- # Check whether --with-devkit was given.
--if test "${with_devkit+set}" = set; then :
-+if test ${with_devkit+y}
-+then :
-   withval=$with_devkit;
- fi
- 
-@@ -15053,8 +16599,8 @@ fi
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of with_devkit" "$LINENO" 5
-   fi
- 
-@@ -15102,8 +16648,8 @@ $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is inval
- 
-   if test "x$path" != "x$new_path"; then
-     with_devkit="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -15140,8 +16686,8 @@ $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     with_devkit="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting with_devkit to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -15152,8 +16698,8 @@ $as_echo "$as_me: Rewriting with_devkit to \"$new_path\"" >&6;}
-     path="$with_devkit"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of with_devkit, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of with_devkit, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -15240,14 +16786,14 @@ $as_echo "$as_me: The path of with_devkit, which resolves as \"$path\", is inval
- 
-     fi
- 
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
--$as_echo_n "checking for devkit... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for devkit" >&5
-+printf %s "checking for devkit... " >&6; }
-     if test "x$DEVKIT_NAME" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
--$as_echo "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_NAME in $DEVKIT_ROOT" >&5
-+printf "%s\n" "$DEVKIT_NAME in $DEVKIT_ROOT" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
--$as_echo "$DEVKIT_ROOT" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DEVKIT_ROOT" >&5
-+printf "%s\n" "$DEVKIT_ROOT" >&6; }
-     fi
- 
- 
-@@ -15297,7 +16843,8 @@ $as_echo "$DEVKIT_ROOT" >&6; }
-   # is not correct.
- 
- # Check whether --with-sys-root was given.
--if test "${with_sys_root+set}" = set; then :
-+if test ${with_sys_root+y}
-+then :
-   withval=$with_sys_root; SYSROOT=$with_sys_root
- 
- fi
-@@ -15305,7 +16852,8 @@ fi
- 
- 
- # Check whether --with-sysroot was given.
--if test "${with_sysroot+set}" = set; then :
-+if test ${with_sysroot+y}
-+then :
-   withval=$with_sysroot; SYSROOT=$with_sysroot
- 
- fi
-@@ -15313,7 +16861,8 @@ fi
- 
- 
- # Check whether --with-tools-dir was given.
--if test "${with_tools_dir+set}" = set; then :
-+if test ${with_tools_dir+y}
-+then :
-   withval=$with_tools_dir;
-   if test "x$with_tools_dir" != x; then
-     if test "x$TOOLCHAIN_PATH" = x; then
-@@ -15329,7 +16878,8 @@ fi
- 
- 
- # Check whether --with-toolchain-path was given.
--if test "${with_toolchain_path+set}" = set; then :
-+if test ${with_toolchain_path+y}
-+then :
-   withval=$with_toolchain_path;
-   if test "x$with_toolchain_path" != x; then
-     if test "x$TOOLCHAIN_PATH" = x; then
-@@ -15345,7 +16895,8 @@ fi
- 
- 
- # Check whether --with-extra-path was given.
--if test "${with_extra_path+set}" = set; then :
-+if test ${with_extra_path+y}
-+then :
-   withval=$with_extra_path;
-   if test "x$with_extra_path" != x; then
-     if test "x$EXTRA_PATH" = x; then
-@@ -15378,24 +16929,25 @@ fi
-   # Xcode version will be validated later
- 
- # Check whether --with-xcode-path was given.
--if test "${with_xcode_path+set}" = set; then :
-+if test ${with_xcode_path+y}
-+then :
-   withval=$with_xcode_path; XCODE_PATH=$with_xcode_path
- 
- fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
--$as_echo_n "checking for sysroot... " >&6; }
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
--$as_echo "$SYSROOT" >&6; }
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
--$as_echo_n "checking for toolchain path... " >&6; }
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
--$as_echo "$TOOLCHAIN_PATH" >&6; }
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
--$as_echo_n "checking for extra path... " >&6; }
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
--$as_echo "$EXTRA_PATH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
-+printf %s "checking for sysroot... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SYSROOT" >&5
-+printf "%s\n" "$SYSROOT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for toolchain path" >&5
-+printf %s "checking for toolchain path... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH" >&5
-+printf "%s\n" "$TOOLCHAIN_PATH" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for extra path" >&5
-+printf %s "checking for extra path... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $EXTRA_PATH" >&5
-+printf "%s\n" "$EXTRA_PATH" >&6; }
- 
- 
- # To properly create a configuration name, we need to have the OpenJDK target
-@@ -15404,26 +16956,27 @@ $as_echo "$EXTRA_PATH" >&6; }
- 
- 
- # Check whether --with-conf-name was given.
--if test "${with_conf_name+set}" = set; then :
-+if test ${with_conf_name+y}
-+then :
-   withval=$with_conf_name;  CONF_NAME=${with_conf_name}
- fi
- 
- 
-   # Test from where we are running configure, in or outside of src root.
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
--$as_echo_n "checking where to store configuration... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking where to store configuration" >&5
-+printf %s "checking where to store configuration... " >&6; }
-   if test "x$CURDIR" = "x$SRC_ROOT" || test "x$CURDIR" = "x$SRC_ROOT/common" \
-       || test "x$CURDIR" = "x$SRC_ROOT/common/autoconf" \
-       || test "x$CURDIR" = "x$SRC_ROOT/make" ; then
-     # We are running configure from the src root.
-     # Create a default ./build/target-variant-debuglevel output root.
-     if test "x${CONF_NAME}" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
--$as_echo "in default location" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: in default location" >&5
-+printf "%s\n" "in default location" >&6; }
-       CONF_NAME="${OPENJDK_TARGET_OS}-${OPENJDK_TARGET_CPU}-${JDK_VARIANT}-${ANDED_JVM_VARIANTS}-${DEBUG_LEVEL}"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
--$as_echo "in build directory with custom name" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: in build directory with custom name" >&5
-+printf "%s\n" "in build directory with custom name" >&6; }
-     fi
-     OUTPUT_ROOT="$SRC_ROOT/build/${CONF_NAME}"
-     $MKDIR -p "$OUTPUT_ROOT"
-@@ -15439,8 +16992,8 @@ $as_echo "in build directory with custom name" >&6; }
-       CONF_NAME=`$ECHO $CURDIR | $SED -e "s!^${SRC_ROOT}/build/!!"`
-     fi
-     OUTPUT_ROOT="$CURDIR"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
--$as_echo "in current directory" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: in current directory" >&5
-+printf "%s\n" "in current directory" >&6; }
- 
-     # WARNING: This might be a bad thing to do. You need to be sure you want to
-     # have a configuration in this directory. Do some sanity checks!
-@@ -15458,28 +17011,28 @@ $as_echo "in current directory" >&6; }
-               -e 's/ //g' \
-           | $TR -d '\n'`
-       if test "x$filtered_files" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
--$as_echo "$as_me: Current directory is $CURDIR." >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
--$as_echo "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
--$as_echo "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
--$as_echo "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
--$as_echo "$as_me: seriously mess up just about everything." >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
--$as_echo "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
--$as_echo "$as_me: (or create a new empty directory and cd to it)." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Current directory is $CURDIR." >&5
-+printf "%s\n" "$as_me: Current directory is $CURDIR." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Since this is not the source root, configure will output the configuration here" >&5
-+printf "%s\n" "$as_me: Since this is not the source root, configure will output the configuration here" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&5
-+printf "%s\n" "$as_me: (as opposed to creating a configuration in <src_root>/build/<conf-name>)." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: However, this directory is not empty. This is not allowed, since it could" >&5
-+printf "%s\n" "$as_me: However, this directory is not empty. This is not allowed, since it could" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: seriously mess up just about everything." >&5
-+printf "%s\n" "$as_me: seriously mess up just about everything." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Try 'cd $SRC_ROOT' and restart configure" >&5
-+printf "%s\n" "$as_me: Try 'cd $SRC_ROOT' and restart configure" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (or create a new empty directory and cd to it)." >&5
-+printf "%s\n" "$as_me: (or create a new empty directory and cd to it)." >&6;}
-         as_fn_error $? "Will not continue creating configuration in $CURDIR" "$LINENO" 5
-       fi
-     fi
-   fi
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
--$as_echo_n "checking what configuration name to use... " >&6; }
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
--$as_echo "$CONF_NAME" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what configuration name to use" >&5
-+printf %s "checking what configuration name to use... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CONF_NAME" >&5
-+printf "%s\n" "$CONF_NAME" >&6; }
- 
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -15501,8 +17054,8 @@ $as_echo "$CONF_NAME" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of OUTPUT_ROOT" "$LINENO" 5
-   fi
- 
-@@ -15550,8 +17103,8 @@ $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is inval
- 
-   if test "x$path" != "x$new_path"; then
-     OUTPUT_ROOT="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -15588,8 +17141,8 @@ $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     OUTPUT_ROOT="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting OUTPUT_ROOT to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -15600,8 +17153,8 @@ $as_echo "$as_me: Rewriting OUTPUT_ROOT to \"$new_path\"" >&6;}
-     path="$OUTPUT_ROOT"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -15653,38 +17206,44 @@ $as_echo "$as_me: The path of OUTPUT_ROOT, which resolves as \"$path\", is inval
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_PKGHANDLER+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$PKGHANDLER"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_PKGHANDLER+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$PKGHANDLER"; then
-   ac_cv_prog_PKGHANDLER="$PKGHANDLER" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_PKGHANDLER="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- PKGHANDLER=$ac_cv_prog_PKGHANDLER
- if test -n "$PKGHANDLER"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
--$as_echo "$PKGHANDLER" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PKGHANDLER" >&5
-+printf "%s\n" "$PKGHANDLER" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -15706,18 +17265,18 @@ done
-   MAKE_CANDIDATE=""$MAKE""
-   DESCRIPTION="user supplied MAKE=$MAKE"
-   if test "x$MAKE_CANDIDATE" != x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
--$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
-+printf "%s\n" "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
-     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
-     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
-     if test "x$IS_GNU_MAKE" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
--$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
-+printf "%s\n" "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
-     else
-       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
-       if test "x$IS_MODERN_MAKE" = x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
--$as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
-+printf "%s\n" "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
-       else
-         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
-           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -15734,8 +17293,8 @@ $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version
-           IS_MAKE_CORRECT_ENV=true
-         fi
-         if test "x$IS_MAKE_CORRECT_ENV" = x; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
--$as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
-+printf "%s\n" "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
-         else
-           FOUND_MAKE=$MAKE_CANDIDATE
- 
-@@ -15779,12 +17338,12 @@ $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -15806,10 +17365,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-   else
-@@ -15919,12 +17478,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -15996,12 +17555,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -16016,8 +17575,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     FOUND_MAKE="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
-   fi
- 
-         fi
-@@ -16034,12 +17593,13 @@ $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CHECK_GMAKE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CHECK_GMAKE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CHECK_GMAKE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CHECK_GMAKE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CHECK_GMAKE="$CHECK_GMAKE" # Let the user override the test with a path.
-   ;;
-@@ -16048,11 +17608,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CHECK_GMAKE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CHECK_GMAKE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -16060,15 +17624,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CHECK_GMAKE=$ac_cv_path_CHECK_GMAKE
- if test -n "$CHECK_GMAKE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
--$as_echo "$CHECK_GMAKE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHECK_GMAKE" >&5
-+printf "%s\n" "$CHECK_GMAKE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -16079,18 +17644,18 @@ done
-   MAKE_CANDIDATE=""$CHECK_GMAKE""
-   DESCRIPTION="gmake in PATH"
-   if test "x$MAKE_CANDIDATE" != x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
--$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
-+printf "%s\n" "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
-     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
-     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
-     if test "x$IS_GNU_MAKE" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
--$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
-+printf "%s\n" "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
-     else
-       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
-       if test "x$IS_MODERN_MAKE" = x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
--$as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
-+printf "%s\n" "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
-       else
-         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
-           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -16107,8 +17672,8 @@ $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version
-           IS_MAKE_CORRECT_ENV=true
-         fi
-         if test "x$IS_MAKE_CORRECT_ENV" = x; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
--$as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
-+printf "%s\n" "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
-         else
-           FOUND_MAKE=$MAKE_CANDIDATE
- 
-@@ -16152,12 +17717,12 @@ $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -16179,10 +17744,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-   else
-@@ -16292,12 +17857,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -16369,12 +17934,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -16389,8 +17954,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     FOUND_MAKE="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
-   fi
- 
-         fi
-@@ -16404,12 +17969,13 @@ $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CHECK_MAKE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CHECK_MAKE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CHECK_MAKE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CHECK_MAKE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CHECK_MAKE="$CHECK_MAKE" # Let the user override the test with a path.
-   ;;
-@@ -16418,11 +17984,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CHECK_MAKE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CHECK_MAKE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -16430,15 +18000,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CHECK_MAKE=$ac_cv_path_CHECK_MAKE
- if test -n "$CHECK_MAKE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
--$as_echo "$CHECK_MAKE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHECK_MAKE" >&5
-+printf "%s\n" "$CHECK_MAKE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -16449,18 +18020,18 @@ done
-   MAKE_CANDIDATE=""$CHECK_MAKE""
-   DESCRIPTION="make in PATH"
-   if test "x$MAKE_CANDIDATE" != x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
--$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
-+printf "%s\n" "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
-     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
-     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
-     if test "x$IS_GNU_MAKE" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
--$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
-+printf "%s\n" "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
-     else
-       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
-       if test "x$IS_MODERN_MAKE" = x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
--$as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
-+printf "%s\n" "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
-       else
-         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
-           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -16477,8 +18048,8 @@ $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version
-           IS_MAKE_CORRECT_ENV=true
-         fi
-         if test "x$IS_MAKE_CORRECT_ENV" = x; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
--$as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
-+printf "%s\n" "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
-         else
-           FOUND_MAKE=$MAKE_CANDIDATE
- 
-@@ -16522,12 +18093,12 @@ $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -16549,10 +18120,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-   else
-@@ -16662,12 +18233,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -16739,12 +18310,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -16759,8 +18330,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     FOUND_MAKE="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
-   fi
- 
-         fi
-@@ -16779,12 +18350,13 @@ $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CHECK_TOOLSDIR_GMAKE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CHECK_TOOLSDIR_GMAKE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CHECK_TOOLSDIR_GMAKE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CHECK_TOOLSDIR_GMAKE="$CHECK_TOOLSDIR_GMAKE" # Let the user override the test with a path.
-   ;;
-@@ -16793,11 +18365,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CHECK_TOOLSDIR_GMAKE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -16805,15 +18381,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CHECK_TOOLSDIR_GMAKE=$ac_cv_path_CHECK_TOOLSDIR_GMAKE
- if test -n "$CHECK_TOOLSDIR_GMAKE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
--$as_echo "$CHECK_TOOLSDIR_GMAKE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_GMAKE" >&5
-+printf "%s\n" "$CHECK_TOOLSDIR_GMAKE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -16824,18 +18401,18 @@ done
-   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_GMAKE""
-   DESCRIPTION="gmake in tools-dir"
-   if test "x$MAKE_CANDIDATE" != x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
--$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
-+printf "%s\n" "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
-     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
-     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
-     if test "x$IS_GNU_MAKE" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
--$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
-+printf "%s\n" "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
-     else
-       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
-       if test "x$IS_MODERN_MAKE" = x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
--$as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
-+printf "%s\n" "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
-       else
-         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
-           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -16852,8 +18429,8 @@ $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version
-           IS_MAKE_CORRECT_ENV=true
-         fi
-         if test "x$IS_MAKE_CORRECT_ENV" = x; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
--$as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
-+printf "%s\n" "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
-         else
-           FOUND_MAKE=$MAKE_CANDIDATE
- 
-@@ -16897,12 +18474,12 @@ $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -16924,10 +18501,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-   else
-@@ -17037,12 +18614,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -17114,12 +18691,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -17134,8 +18711,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     FOUND_MAKE="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
-   fi
- 
-         fi
-@@ -17148,12 +18725,13 @@ $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CHECK_TOOLSDIR_MAKE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CHECK_TOOLSDIR_MAKE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CHECK_TOOLSDIR_MAKE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CHECK_TOOLSDIR_MAKE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CHECK_TOOLSDIR_MAKE="$CHECK_TOOLSDIR_MAKE" # Let the user override the test with a path.
-   ;;
-@@ -17162,11 +18740,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CHECK_TOOLSDIR_MAKE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -17174,15 +18756,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CHECK_TOOLSDIR_MAKE=$ac_cv_path_CHECK_TOOLSDIR_MAKE
- if test -n "$CHECK_TOOLSDIR_MAKE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
--$as_echo "$CHECK_TOOLSDIR_MAKE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CHECK_TOOLSDIR_MAKE" >&5
-+printf "%s\n" "$CHECK_TOOLSDIR_MAKE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -17193,18 +18776,18 @@ done
-   MAKE_CANDIDATE=""$CHECK_TOOLSDIR_MAKE""
-   DESCRIPTION="make in tools-dir"
-   if test "x$MAKE_CANDIDATE" != x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
--$as_echo "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&5
-+printf "%s\n" "$as_me: Testing potential make at $MAKE_CANDIDATE, found using $DESCRIPTION" >&6;}
-     MAKE_VERSION_STRING=`$MAKE_CANDIDATE --version | $HEAD -n 1`
-     IS_GNU_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP 'GNU Make'`
-     if test "x$IS_GNU_MAKE" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
--$as_echo "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&5
-+printf "%s\n" "$as_me: Found potential make at $MAKE_CANDIDATE, however, this is not GNU Make. Ignoring." >&6;}
-     else
-       IS_MODERN_MAKE=`$ECHO $MAKE_VERSION_STRING | $GREP -e '3\.8[12]' -e '4\.'`
-       if test "x$IS_MODERN_MAKE" = x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
--$as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&5
-+printf "%s\n" "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version 3.81 or later. (it is: $MAKE_VERSION_STRING). Ignoring." >&6;}
-       else
-         if test "x$OPENJDK_BUILD_OS" = "xwindows"; then
-           if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -17221,8 +18804,8 @@ $as_echo "$as_me: Found GNU make at $MAKE_CANDIDATE, however this is not version
-           IS_MAKE_CORRECT_ENV=true
-         fi
-         if test "x$IS_MAKE_CORRECT_ENV" = x; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
--$as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&5
-+printf "%s\n" "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE, but it is not for $MAKE_EXPECTED_ENV (it says: $MAKE_BUILT_FOR). Ignoring." >&6;}
-         else
-           FOUND_MAKE=$MAKE_CANDIDATE
- 
-@@ -17266,12 +18849,12 @@ $as_echo "$as_me: Found GNU make version $MAKE_VERSION_STRING at $MAKE_CANDIDATE
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -17293,10 +18876,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-   else
-@@ -17406,12 +18989,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -17483,12 +19066,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of FOUND_MAKE, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of FOUND_MAKE" "$LINENO" 5
-     fi
-@@ -17503,8 +19086,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     FOUND_MAKE="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting FOUND_MAKE to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
-   fi
- 
-         fi
-@@ -17524,14 +19107,14 @@ $as_echo "$as_me: Rewriting FOUND_MAKE to \"$new_complete\"" >&6;}
- 
-   MAKE=$FOUND_MAKE
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
--$as_echo "$as_me: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&5
-+printf "%s\n" "$as_me: Using GNU make 3.81 (or later) at $FOUND_MAKE (version: $MAKE_VERSION_STRING)" >&6;}
- 
- 
- 
-   # Test if find supports -delete
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
--$as_echo_n "checking if find supports -delete... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if find supports -delete" >&5
-+printf %s "checking if find supports -delete... " >&6; }
-   FIND_DELETE="-delete"
- 
-   DELETEDIR=`$MKTEMP -d tmp.XXXXXXXXXX` || (echo Could not create temporary directory!; exit $?)
-@@ -17543,11 +19126,11 @@ $as_echo_n "checking if find supports -delete... " >&6; }
-     # No, it does not.
-     rm $DELETEDIR/TestIfFindSupportsDelete
-     FIND_DELETE="-exec rm \{\} \+"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-   else
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
-   fi
-   rmdir $DELETEDIR
- 
-@@ -17567,12 +19150,13 @@ $as_echo "yes" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_UNZIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $UNZIP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_UNZIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $UNZIP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
-   ;;
-@@ -17581,11 +19165,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_UNZIP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -17593,15 +19181,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- UNZIP=$ac_cv_path_UNZIP
- if test -n "$UNZIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
--$as_echo "$UNZIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
-+printf "%s\n" "$UNZIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -17617,20 +19206,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xUNZIP" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of UNZIP from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in unzip
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_UNZIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $UNZIP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_UNZIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $UNZIP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
-   ;;
-@@ -17639,11 +19229,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_UNZIP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -17651,15 +19245,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- UNZIP=$ac_cv_path_UNZIP
- if test -n "$UNZIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
--$as_echo "$UNZIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
-+printf "%s\n" "$UNZIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -17679,16 +19274,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool UNZIP=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool UNZIP=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_UNZIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $UNZIP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_UNZIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $UNZIP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_UNZIP="$UNZIP" # Let the user override the test with a path.
-   ;;
-@@ -17697,11 +19293,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_UNZIP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_UNZIP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -17709,15 +19309,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- UNZIP=$ac_cv_path_UNZIP
- if test -n "$UNZIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
--$as_echo "$UNZIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UNZIP" >&5
-+printf "%s\n" "$UNZIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -17726,17 +19327,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
--$as_echo_n "checking for UNZIP... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool UNZIP=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool UNZIP=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for UNZIP" >&5
-+printf %s "checking for UNZIP... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool UNZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -17760,12 +19361,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_ZIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $ZIP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_ZIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $ZIP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
-   ;;
-@@ -17774,11 +19376,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_ZIP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -17786,15 +19392,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- ZIP=$ac_cv_path_ZIP
- if test -n "$ZIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
--$as_echo "$ZIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
-+printf "%s\n" "$ZIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -17810,20 +19417,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xZIP" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of ZIP from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in zip
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_ZIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $ZIP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_ZIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $ZIP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
-   ;;
-@@ -17832,11 +19440,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_ZIP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -17844,15 +19456,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- ZIP=$ac_cv_path_ZIP
- if test -n "$ZIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
--$as_echo "$ZIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
-+printf "%s\n" "$ZIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -17872,16 +19485,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool ZIP=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool ZIP=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_ZIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $ZIP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_ZIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $ZIP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_ZIP="$ZIP" # Let the user override the test with a path.
-   ;;
-@@ -17890,11 +19504,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_ZIP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_ZIP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -17902,15 +19520,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- ZIP=$ac_cv_path_ZIP
- if test -n "$ZIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
--$as_echo "$ZIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ZIP" >&5
-+printf "%s\n" "$ZIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -17919,17 +19538,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
--$as_echo_n "checking for ZIP... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool ZIP=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool ZIP=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ZIP" >&5
-+printf %s "checking for ZIP... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool ZIP=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -17955,12 +19574,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_LDD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $LDD in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_LDD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $LDD in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
-   ;;
-@@ -17969,11 +19589,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_LDD="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -17981,15 +19605,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- LDD=$ac_cv_path_LDD
- if test -n "$LDD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
--$as_echo "$LDD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
-+printf "%s\n" "$LDD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18005,20 +19630,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xLDD" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of LDD from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in ldd
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_LDD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $LDD in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_LDD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $LDD in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
-   ;;
-@@ -18027,11 +19653,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_LDD="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18039,15 +19669,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- LDD=$ac_cv_path_LDD
- if test -n "$LDD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
--$as_echo "$LDD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
-+printf "%s\n" "$LDD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18067,16 +19698,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LDD=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool LDD=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_LDD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $LDD in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_LDD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $LDD in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_LDD="$LDD" # Let the user override the test with a path.
-   ;;
-@@ -18085,11 +19717,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_LDD="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_LDD="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18097,15 +19733,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- LDD=$ac_cv_path_LDD
- if test -n "$LDD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
--$as_echo "$LDD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LDD" >&5
-+printf "%s\n" "$LDD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18114,17 +19751,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
--$as_echo_n "checking for LDD... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LDD=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool LDD=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for LDD" >&5
-+printf %s "checking for LDD... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool LDD=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -18147,12 +19784,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_READELF+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $READELF in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_READELF+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $READELF in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
-   ;;
-@@ -18161,11 +19799,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_READELF="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18173,15 +19815,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- READELF=$ac_cv_path_READELF
- if test -n "$READELF"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
--$as_echo "$READELF" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
-+printf "%s\n" "$READELF" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18197,20 +19840,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xREADELF" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of READELF from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in readelf greadelf
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_READELF+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $READELF in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_READELF+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $READELF in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
-   ;;
-@@ -18219,11 +19863,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_READELF="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18231,15 +19879,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- READELF=$ac_cv_path_READELF
- if test -n "$READELF"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
--$as_echo "$READELF" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
-+printf "%s\n" "$READELF" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18259,16 +19908,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool READELF=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool READELF=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_READELF+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $READELF in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_READELF+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $READELF in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_READELF="$READELF" # Let the user override the test with a path.
-   ;;
-@@ -18277,11 +19927,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_READELF="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_READELF="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18289,15 +19943,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- READELF=$ac_cv_path_READELF
- if test -n "$READELF"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
--$as_echo "$READELF" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $READELF" >&5
-+printf "%s\n" "$READELF" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18306,17 +19961,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
--$as_echo_n "checking for READELF... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool READELF=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool READELF=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for READELF" >&5
-+printf %s "checking for READELF... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool READELF=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -18333,12 +19988,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_HG+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $HG in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_HG+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $HG in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_HG="$HG" # Let the user override the test with a path.
-   ;;
-@@ -18347,11 +20003,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_HG="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18359,15 +20019,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- HG=$ac_cv_path_HG
- if test -n "$HG"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
--$as_echo "$HG" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
-+printf "%s\n" "$HG" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18383,20 +20044,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xHG" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of HG from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in hg
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_HG+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $HG in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_HG+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $HG in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_HG="$HG" # Let the user override the test with a path.
-   ;;
-@@ -18405,11 +20067,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_HG="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18417,15 +20083,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- HG=$ac_cv_path_HG
- if test -n "$HG"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
--$as_echo "$HG" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
-+printf "%s\n" "$HG" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18445,16 +20112,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool HG=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool HG=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_HG+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $HG in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_HG+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $HG in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_HG="$HG" # Let the user override the test with a path.
-   ;;
-@@ -18463,11 +20131,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_HG="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_HG="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18475,15 +20147,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- HG=$ac_cv_path_HG
- if test -n "$HG"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
--$as_echo "$HG" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $HG" >&5
-+printf "%s\n" "$HG" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18492,17 +20165,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
--$as_echo_n "checking for HG... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool HG=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool HG=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for HG" >&5
-+printf %s "checking for HG... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool HG=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -18519,12 +20192,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_GIT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $GIT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_GIT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $GIT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_GIT="$GIT" # Let the user override the test with a path.
-   ;;
-@@ -18533,11 +20207,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_GIT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_GIT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18545,15 +20223,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- GIT=$ac_cv_path_GIT
- if test -n "$GIT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GIT" >&5
--$as_echo "$GIT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GIT" >&5
-+printf "%s\n" "$GIT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18569,20 +20248,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xGIT" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GIT from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of GIT from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GIT from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of GIT from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in git
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_GIT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $GIT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_GIT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $GIT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_GIT="$GIT" # Let the user override the test with a path.
-   ;;
-@@ -18591,11 +20271,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_GIT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_GIT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18603,15 +20287,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- GIT=$ac_cv_path_GIT
- if test -n "$GIT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GIT" >&5
--$as_echo "$GIT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GIT" >&5
-+printf "%s\n" "$GIT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18631,16 +20316,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GIT=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool GIT=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GIT=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool GIT=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_GIT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $GIT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_GIT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $GIT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_GIT="$GIT" # Let the user override the test with a path.
-   ;;
-@@ -18649,11 +20335,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_GIT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_GIT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18661,15 +20351,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- GIT=$ac_cv_path_GIT
- if test -n "$GIT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GIT" >&5
--$as_echo "$GIT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GIT" >&5
-+printf "%s\n" "$GIT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18678,17 +20369,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GIT=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool GIT=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GIT" >&5
--$as_echo_n "checking for GIT... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GIT=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool GIT=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GIT" >&5
-+printf %s "checking for GIT... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool GIT=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -18705,12 +20396,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_STAT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $STAT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_STAT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $STAT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
-   ;;
-@@ -18719,11 +20411,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_STAT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18731,15 +20427,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- STAT=$ac_cv_path_STAT
- if test -n "$STAT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
--$as_echo "$STAT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
-+printf "%s\n" "$STAT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18755,20 +20452,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xSTAT" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of STAT from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in stat
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_STAT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $STAT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_STAT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $STAT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
-   ;;
-@@ -18777,11 +20475,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_STAT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18789,15 +20491,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- STAT=$ac_cv_path_STAT
- if test -n "$STAT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
--$as_echo "$STAT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
-+printf "%s\n" "$STAT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18817,16 +20520,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STAT=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool STAT=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_STAT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $STAT in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_STAT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $STAT in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_STAT="$STAT" # Let the user override the test with a path.
-   ;;
-@@ -18835,11 +20539,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_STAT="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_STAT="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18847,15 +20555,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- STAT=$ac_cv_path_STAT
- if test -n "$STAT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
--$as_echo "$STAT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STAT" >&5
-+printf "%s\n" "$STAT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18864,17 +20573,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
--$as_echo_n "checking for STAT... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STAT=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool STAT=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for STAT" >&5
-+printf %s "checking for STAT... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool STAT=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -18891,12 +20600,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TIME+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TIME in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TIME+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TIME in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
-   ;;
-@@ -18905,11 +20615,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TIME="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18917,15 +20631,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TIME=$ac_cv_path_TIME
- if test -n "$TIME"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
--$as_echo "$TIME" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
-+printf "%s\n" "$TIME" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -18941,20 +20656,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xTIME" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of TIME from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in time
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TIME+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TIME in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TIME+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TIME in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
-   ;;
-@@ -18963,11 +20679,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TIME="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -18975,15 +20695,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TIME=$ac_cv_path_TIME
- if test -n "$TIME"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
--$as_echo "$TIME" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
-+printf "%s\n" "$TIME" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19003,16 +20724,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool TIME=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool TIME=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TIME+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TIME in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TIME+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TIME in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TIME="$TIME" # Let the user override the test with a path.
-   ;;
-@@ -19021,11 +20743,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TIME="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TIME="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19033,15 +20759,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TIME=$ac_cv_path_TIME
- if test -n "$TIME"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
--$as_echo "$TIME" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TIME" >&5
-+printf "%s\n" "$TIME" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19050,17 +20777,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
--$as_echo_n "checking for TIME... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool TIME=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool TIME=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for TIME" >&5
-+printf %s "checking for TIME... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool TIME=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -19088,12 +20815,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_COMM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $COMM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_COMM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $COMM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
-   ;;
-@@ -19102,11 +20830,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_COMM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19114,15 +20846,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- COMM=$ac_cv_path_COMM
- if test -n "$COMM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
--$as_echo "$COMM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
-+printf "%s\n" "$COMM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19138,20 +20871,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xCOMM" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of COMM from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in comm
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_COMM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $COMM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_COMM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $COMM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
-   ;;
-@@ -19160,11 +20894,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_COMM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19172,15 +20910,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- COMM=$ac_cv_path_COMM
- if test -n "$COMM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
--$as_echo "$COMM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
-+printf "%s\n" "$COMM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19200,16 +20939,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool COMM=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool COMM=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_COMM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $COMM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_COMM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $COMM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_COMM="$COMM" # Let the user override the test with a path.
-   ;;
-@@ -19218,11 +20958,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_COMM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_COMM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19230,15 +20974,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- COMM=$ac_cv_path_COMM
- if test -n "$COMM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
--$as_echo "$COMM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $COMM" >&5
-+printf "%s\n" "$COMM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19247,17 +20992,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
--$as_echo_n "checking for COMM... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool COMM=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool COMM=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for COMM" >&5
-+printf %s "checking for COMM... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool COMM=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -19284,12 +21029,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DSYMUTIL+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DSYMUTIL in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DSYMUTIL+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DSYMUTIL in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
-   ;;
-@@ -19298,11 +21044,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DSYMUTIL="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19310,15 +21060,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DSYMUTIL=$ac_cv_path_DSYMUTIL
- if test -n "$DSYMUTIL"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
--$as_echo "$DSYMUTIL" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
-+printf "%s\n" "$DSYMUTIL" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19334,20 +21085,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xDSYMUTIL" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of DSYMUTIL from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in dsymutil
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DSYMUTIL+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DSYMUTIL in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DSYMUTIL+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DSYMUTIL in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
-   ;;
-@@ -19356,11 +21108,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DSYMUTIL="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19368,15 +21124,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DSYMUTIL=$ac_cv_path_DSYMUTIL
- if test -n "$DSYMUTIL"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
--$as_echo "$DSYMUTIL" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
-+printf "%s\n" "$DSYMUTIL" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19396,16 +21153,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool DSYMUTIL=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool DSYMUTIL=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_DSYMUTIL+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $DSYMUTIL in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_DSYMUTIL+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $DSYMUTIL in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_DSYMUTIL="$DSYMUTIL" # Let the user override the test with a path.
-   ;;
-@@ -19414,11 +21172,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_DSYMUTIL="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_DSYMUTIL="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19426,15 +21188,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- DSYMUTIL=$ac_cv_path_DSYMUTIL
- if test -n "$DSYMUTIL"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
--$as_echo "$DSYMUTIL" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
-+printf "%s\n" "$DSYMUTIL" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19443,17 +21206,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
--$as_echo_n "checking for DSYMUTIL... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool DSYMUTIL=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool DSYMUTIL=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for DSYMUTIL" >&5
-+printf %s "checking for DSYMUTIL... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool DSYMUTIL=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -19477,12 +21240,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_XATTR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $XATTR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_XATTR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $XATTR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
-   ;;
-@@ -19491,11 +21255,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_XATTR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19503,15 +21271,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- XATTR=$ac_cv_path_XATTR
- if test -n "$XATTR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
--$as_echo "$XATTR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
-+printf "%s\n" "$XATTR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19527,20 +21296,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xXATTR" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of XATTR from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in xattr
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_XATTR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $XATTR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_XATTR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $XATTR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
-   ;;
-@@ -19549,11 +21319,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_XATTR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19561,15 +21335,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- XATTR=$ac_cv_path_XATTR
- if test -n "$XATTR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
--$as_echo "$XATTR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
-+printf "%s\n" "$XATTR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19589,16 +21364,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool XATTR=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool XATTR=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_XATTR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $XATTR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_XATTR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $XATTR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_XATTR="$XATTR" # Let the user override the test with a path.
-   ;;
-@@ -19607,11 +21383,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_XATTR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_XATTR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19619,15 +21399,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- XATTR=$ac_cv_path_XATTR
- if test -n "$XATTR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
--$as_echo "$XATTR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XATTR" >&5
-+printf "%s\n" "$XATTR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19636,17 +21417,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
--$as_echo_n "checking for XATTR... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool XATTR=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool XATTR=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for XATTR" >&5
-+printf %s "checking for XATTR... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool XATTR=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -19669,12 +21450,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CODESIGN+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CODESIGN in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CODESIGN+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CODESIGN in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
-   ;;
-@@ -19683,11 +21465,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CODESIGN="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19695,15 +21481,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CODESIGN=$ac_cv_path_CODESIGN
- if test -n "$CODESIGN"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
--$as_echo "$CODESIGN" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
-+printf "%s\n" "$CODESIGN" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19719,20 +21506,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xCODESIGN" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of CODESIGN from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in codesign
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CODESIGN+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CODESIGN in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CODESIGN+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CODESIGN in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
-   ;;
-@@ -19741,11 +21529,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CODESIGN="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19753,15 +21545,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CODESIGN=$ac_cv_path_CODESIGN
- if test -n "$CODESIGN"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
--$as_echo "$CODESIGN" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
-+printf "%s\n" "$CODESIGN" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19781,16 +21574,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CODESIGN=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool CODESIGN=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CODESIGN+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CODESIGN in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CODESIGN+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CODESIGN in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CODESIGN="$CODESIGN" # Let the user override the test with a path.
-   ;;
-@@ -19799,11 +21593,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CODESIGN="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CODESIGN="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19811,15 +21609,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CODESIGN=$ac_cv_path_CODESIGN
- if test -n "$CODESIGN"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
--$as_echo "$CODESIGN" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CODESIGN" >&5
-+printf "%s\n" "$CODESIGN" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19828,17 +21627,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
--$as_echo_n "checking for CODESIGN... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CODESIGN=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool CODESIGN=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CODESIGN" >&5
-+printf %s "checking for CODESIGN... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool CODESIGN=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -19846,18 +21645,18 @@ $as_echo "$tool_specified" >&6; }
- 
-     if test "x$CODESIGN" != "x"; then
-       # Verify that the openjdk_codesign certificate is present
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
--$as_echo_n "checking if openjdk_codesign certificate is present... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if openjdk_codesign certificate is present" >&5
-+printf %s "checking if openjdk_codesign certificate is present... " >&6; }
-       rm -f codesign-testfile
-       touch codesign-testfile
-       codesign -s openjdk_codesign codesign-testfile 2>&5 >&5 || CODESIGN=
-       rm -f codesign-testfile
-       if test "x$CODESIGN" = x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-       else
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
-       fi
-     fi
-   fi
-@@ -19870,12 +21669,13 @@ if test "x$ac_cv_env_PKG_CONFIG_set" != "xset"; then
- 	if test -n "$ac_tool_prefix"; then
-   # Extract the first word of "${ac_tool_prefix}pkg-config", so it can be a program name with args.
- set dummy ${ac_tool_prefix}pkg-config; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_PKG_CONFIG+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $PKG_CONFIG in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_PKG_CONFIG+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $PKG_CONFIG in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_PKG_CONFIG="$PKG_CONFIG" # Let the user override the test with a path.
-   ;;
-@@ -19884,11 +21684,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_PKG_CONFIG="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19896,15 +21700,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- PKG_CONFIG=$ac_cv_path_PKG_CONFIG
- if test -n "$PKG_CONFIG"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
--$as_echo "$PKG_CONFIG" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PKG_CONFIG" >&5
-+printf "%s\n" "$PKG_CONFIG" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -19913,12 +21718,13 @@ if test -z "$ac_cv_path_PKG_CONFIG"; then
-   ac_pt_PKG_CONFIG=$PKG_CONFIG
-   # Extract the first word of "pkg-config", so it can be a program name with args.
- set dummy pkg-config; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_ac_pt_PKG_CONFIG+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $ac_pt_PKG_CONFIG in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_ac_pt_PKG_CONFIG+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $ac_pt_PKG_CONFIG in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_ac_pt_PKG_CONFIG="$ac_pt_PKG_CONFIG" # Let the user override the test with a path.
-   ;;
-@@ -19927,11 +21733,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_ac_pt_PKG_CONFIG="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_ac_pt_PKG_CONFIG="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -19939,15 +21749,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- ac_pt_PKG_CONFIG=$ac_cv_path_ac_pt_PKG_CONFIG
- if test -n "$ac_pt_PKG_CONFIG"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
--$as_echo "$ac_pt_PKG_CONFIG" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_pt_PKG_CONFIG" >&5
-+printf "%s\n" "$ac_pt_PKG_CONFIG" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
-   if test "x$ac_pt_PKG_CONFIG" = x; then
-@@ -19955,8 +21766,8 @@ fi
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     PKG_CONFIG=$ac_pt_PKG_CONFIG
-@@ -19968,14 +21779,14 @@ fi
- fi
- if test -n "$PKG_CONFIG"; then
- 	_pkg_min_version=0.9.0
--	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
--$as_echo_n "checking pkg-config is at least version $_pkg_min_version... " >&6; }
-+	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking pkg-config is at least version $_pkg_min_version" >&5
-+printf %s "checking pkg-config is at least version $_pkg_min_version... " >&6; }
- 	if $PKG_CONFIG --atleast-pkgconfig-version $_pkg_min_version; then
--		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+		{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
- 	else
--		{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+		{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- 		PKG_CONFIG=""
- 	fi
- 
-@@ -20002,30 +21813,35 @@ fi
- 
- 
- # Check whether --with-builddeps-conf was given.
--if test "${with_builddeps_conf+set}" = set; then :
-+if test ${with_builddeps_conf+y}
-+then :
-   withval=$with_builddeps_conf;
- fi
- 
- 
- 
- # Check whether --with-builddeps-server was given.
--if test "${with_builddeps_server+set}" = set; then :
-+if test ${with_builddeps_server+y}
-+then :
-   withval=$with_builddeps_server;
- fi
- 
- 
- 
- # Check whether --with-builddeps-dir was given.
--if test "${with_builddeps_dir+set}" = set; then :
-+if test ${with_builddeps_dir+y}
-+then :
-   withval=$with_builddeps_dir;
--else
--  with_builddeps_dir=/localhome/builddeps
-+else case e in #(
-+  e) with_builddeps_dir=/localhome/builddeps ;;
-+esac
- fi
- 
- 
- 
- # Check whether --with-builddeps-group was given.
--if test "${with_builddeps_group+set}" = set; then :
-+if test ${with_builddeps_group+y}
-+then :
-   withval=$with_builddeps_group;
- fi
- 
-@@ -20034,19 +21850,19 @@ fi
- 
-   if test "x$with_builddeps_server" != x || test "x$with_builddeps_conf" != x; then
-     if test "x$with_builddeps_conf" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5
--$as_echo_n "checking for supplied builddeps configuration file... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for supplied builddeps configuration file" >&5
-+printf %s "checking for supplied builddeps configuration file... " >&6; }
-       builddepsfile=$with_builddeps_conf
-       if test -s $builddepsfile; then
-         . $builddepsfile
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5
--$as_echo "loaded!" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: loaded!" >&5
-+printf "%s\n" "loaded!" >&6; }
-       else
-         as_fn_error $? "The given builddeps conf file $with_builddeps_conf could not be loaded!" "$LINENO" 5
-       fi
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5
--$as_echo_n "checking for builddeps.conf files in sources...... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for builddeps.conf files in sources..." >&5
-+printf %s "checking for builddeps.conf files in sources...... " >&6; }
-       builddepsfile=`mktemp`
-       touch $builddepsfile
-       # Put all found confs into a single file.
-@@ -20054,8 +21870,8 @@ $as_echo_n "checking for builddeps.conf files in sources...... " >&6; }
-       # Source the file to acquire the variables
-       if test -s $builddepsfile; then
-         . $builddepsfile
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5
--$as_echo "found at least one!" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: found at least one!" >&5
-+printf "%s\n" "found at least one!" >&6; }
-       else
-         as_fn_error $? "Could not find any builddeps.conf at all!" "$LINENO" 5
-       fi
-@@ -20086,38 +21902,44 @@ $as_echo "found at least one!" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_BDEPS_UNZIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$BDEPS_UNZIP"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_BDEPS_UNZIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$BDEPS_UNZIP"; then
-   ac_cv_prog_BDEPS_UNZIP="$BDEPS_UNZIP" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_BDEPS_UNZIP="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- BDEPS_UNZIP=$ac_cv_prog_BDEPS_UNZIP
- if test -n "$BDEPS_UNZIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5
--$as_echo "$BDEPS_UNZIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BDEPS_UNZIP" >&5
-+printf "%s\n" "$BDEPS_UNZIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -20132,38 +21954,44 @@ done
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_BDEPS_FTP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$BDEPS_FTP"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_BDEPS_FTP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$BDEPS_FTP"; then
-   ac_cv_prog_BDEPS_FTP="$BDEPS_FTP" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_BDEPS_FTP="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- BDEPS_FTP=$ac_cv_prog_BDEPS_FTP
- if test -n "$BDEPS_FTP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5
--$as_echo "$BDEPS_FTP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BDEPS_FTP" >&5
-+printf "%s\n" "$BDEPS_FTP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -20186,13 +22014,15 @@ done
-   # Should we build a JDK/JVM with headful support (ie a graphical ui)?
-   # We always build headless support.
-   #
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
--$as_echo_n "checking headful support... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking headful support" >&5
-+printf %s "checking headful support... " >&6; }
-   # Check whether --enable-headful was given.
--if test "${enable_headful+set}" = set; then :
-+if test ${enable_headful+y}
-+then :
-   enableval=$enable_headful; SUPPORT_HEADFUL=${enable_headful}
--else
--  SUPPORT_HEADFUL=yes
-+else case e in #(
-+  e) SUPPORT_HEADFUL=yes ;;
-+esac
- fi
- 
- 
-@@ -20210,8 +22040,8 @@ fi
-     headful_msg="headless only"
-   fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
--$as_echo "$headful_msg" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $headful_msg" >&5
-+printf "%s\n" "$headful_msg" >&6; }
- 
- 
- 
-@@ -20219,10 +22049,12 @@ $as_echo "$headful_msg" >&6; }
- 
-   # Control wether Hotspot runs Queens test after build.
-   # Check whether --enable-hotspot-test-in-build was given.
--if test "${enable_hotspot_test_in_build+set}" = set; then :
-+if test ${enable_hotspot_test_in_build+y}
-+then :
-   enableval=$enable_hotspot_test_in_build;
--else
--  enable_hotspot_test_in_build=no
-+else case e in #(
-+  e) enable_hotspot_test_in_build=no ;;
-+esac
- fi
- 
-   if test "x$enable_hotspot_test_in_build" = "xyes"; then
-@@ -20238,7 +22070,8 @@ fi
-   #
- 
- # Check whether --with-cacerts-file was given.
--if test "${with_cacerts_file+set}" = set; then :
-+if test ${with_cacerts_file+y}
-+then :
-   withval=$with_cacerts_file;
- fi
- 
-@@ -20252,10 +22085,12 @@ fi
-   # Enable or disable unlimited crypto
-   #
-   # Check whether --enable-unlimited-crypto was given.
--if test "${enable_unlimited_crypto+set}" = set; then :
-+if test ${enable_unlimited_crypto+y}
-+then :
-   enableval=$enable_unlimited_crypto;
--else
--  enable_unlimited_crypto=no
-+else case e in #(
-+  e) enable_unlimited_crypto=no ;;
-+esac
- fi
- 
-   if test "x$enable_unlimited_crypto" = "xyes"; then
-@@ -20283,13 +22118,15 @@ fi
-   #
-   # Enable or disable JFR
-   #
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build JFR" >&5
--$as_echo_n "checking whether to build JFR... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to build JFR" >&5
-+printf %s "checking whether to build JFR... " >&6; }
-   # Check whether --enable-jfr was given.
--if test "${enable_jfr+set}" = set; then :
-+if test ${enable_jfr+y}
-+then :
-   enableval=$enable_jfr;
--else
--  enable_jfr=auto
-+else case e in #(
-+  e) enable_jfr=auto ;;
-+esac
- fi
- 
-   if test "x$enable_jfr" = "xno"; then
-@@ -20313,8 +22150,8 @@ fi
-   else
-     as_fn_error $? "--enable-jfr must be set to either yes or no" "$LINENO" 5
-   fi
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_JFR" >&5
--$as_echo "$ENABLE_JFR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ENABLE_JFR" >&5
-+printf "%s\n" "$ENABLE_JFR" >&6; }
- 
- 
- 
-@@ -20324,7 +22161,8 @@ $as_echo "$ENABLE_JFR" >&6; }
-   # Get the settings from parameters
- 
- # Check whether --with-milestone was given.
--if test "${with_milestone+set}" = set; then :
-+if test ${with_milestone+y}
-+then :
-   withval=$with_milestone;
- fi
- 
-@@ -20339,7 +22177,8 @@ fi
- 
- 
- # Check whether --with-update-version was given.
--if test "${with_update_version+set}" = set; then :
-+if test ${with_update_version+y}
-+then :
-   withval=$with_update_version;
- fi
- 
-@@ -20357,7 +22196,8 @@ fi
- 
- 
- # Check whether --with-user-release-suffix was given.
--if test "${with_user_release_suffix+set}" = set; then :
-+if test ${with_user_release_suffix+y}
-+then :
-   withval=$with_user_release_suffix;
- fi
- 
-@@ -20369,7 +22209,8 @@ fi
- 
- 
- # Check whether --with-build-number was given.
--if test "${with_build_number+set}" = set; then :
-+if test ${with_build_number+y}
-+then :
-   withval=$with_build_number;
- fi
- 
-@@ -20404,10 +22245,28 @@ fi
- 
- 
- 
-+  # The company name, if any
-+
-+# Check whether --with-company-name was given.
-+if test ${with_company_name+y}
-+then :
-+  withval=$with_company_name;
-+fi
-+
-+  if test "x$with_company_name" = xyes; then
-+    as_fn_error $? "--with-company-name must have a value" "$LINENO" 5
-+  elif  ! [[ $with_company_name =~ ^[[:print:]]*$ ]] ; then
-+    as_fn_error $? "--with-company-name contains non-printing characters: $with_company_name" "$LINENO" 5
-+  elif test "x$with_company_name" != x; then
-+    COMPANY_NAME="$with_company_name"
-+  fi
-+
-+
-   # The vendor name, if any
- 
- # Check whether --with-vendor-name was given.
--if test "${with_vendor_name+set}" = set; then :
-+if test ${with_vendor_name+y}
-+then :
-   withval=$with_vendor_name;
- fi
- 
-@@ -20425,7 +22284,8 @@ fi
-   # The vendor URL, if any
- 
- # Check whether --with-vendor-url was given.
--if test "${with_vendor_url+set}" = set; then :
-+if test ${with_vendor_url+y}
-+then :
-   withval=$with_vendor_url;
- fi
- 
-@@ -20441,7 +22301,8 @@ fi
-   # The vendor bug URL, if any
- 
- # Check whether --with-vendor-bug-url was given.
--if test "${with_vendor_bug_url+set}" = set; then :
-+if test ${with_vendor_bug_url+y}
-+then :
-   withval=$with_vendor_bug_url;
- fi
- 
-@@ -20457,7 +22318,8 @@ fi
-   # The vendor VM bug URL, if any
- 
- # Check whether --with-vendor-vm-bug-url was given.
--if test "${with_vendor_vm_bug_url+set}" = set; then :
-+if test ${with_vendor_vm_bug_url+y}
-+then :
-   withval=$with_vendor_vm_bug_url;
- fi
- 
-@@ -20472,7 +22334,8 @@ fi
- 
- 
- # Check whether --with-copyright-year was given.
--if test "${with_copyright_year+set}" = set; then :
-+if test ${with_copyright_year+y}
-+then :
-   withval=$with_copyright_year;
- fi
- 
-@@ -20512,7 +22375,8 @@ fi
-   BOOT_JDK_FOUND=no
- 
- # Check whether --with-boot-jdk was given.
--if test "${with_boot_jdk+set}" = set; then :
-+if test ${with_boot_jdk+y}
-+then :
-   withval=$with_boot_jdk;
- fi
- 
-@@ -20530,8 +22394,8 @@ fi
-   if test "x$with_boot_jdk" != x; then
-     BOOT_JDK=$with_boot_jdk
-     BOOT_JDK_FOUND=maybe
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
--$as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using configure arguments" >&5
-+printf "%s\n" "$as_me: Found potential Boot JDK using configure arguments" >&6;}
-   fi
- 
- 
-@@ -20539,22 +22403,22 @@ $as_echo "$as_me: Found potential Boot JDK using configure arguments" >&6;}
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -20563,10 +22427,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -20591,8 +22455,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -20640,8 +22504,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -20678,8 +22542,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -20690,8 +22554,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -20704,15 +22568,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -20752,8 +22616,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-       resource=${builddep_bootjdk}
-     fi
-     if test "x$resource" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for bootjdk" >&5
--$as_echo "$as_me: Using builddeps $resource for bootjdk" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for bootjdk" >&5
-+printf "%s\n" "$as_me: Using builddeps $resource for bootjdk" >&6;}
-       # If the resource in the builddeps.conf file is an existing directory,
-       # for example /java/linux/cups
-       if test -d ${resource}; then
-@@ -20773,8 +22637,8 @@ $as_echo "$as_me: Using builddeps $resource for bootjdk" >&6;}
-   extension=${filename#*.}
-   installdir=$with_builddeps_dir/$filebase
-   if test ! -f $installdir/$filename.unpacked; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&5
--$as_echo "$as_me: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&5
-+printf "%s\n" "$as_me: Downloading build dependency bootjdk from $with_builddeps_server/$resource and installing into $installdir" >&6;}
-     if test ! -d $installdir; then
-       mkdir -p $installdir
-     fi
-@@ -20882,22 +22746,22 @@ $as_echo "$as_me: Downloading build dependency bootjdk from $with_builddeps_serv
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -20906,10 +22770,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -20934,8 +22798,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -20983,8 +22847,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -21021,8 +22885,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -21033,8 +22897,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -21047,15 +22911,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -21091,8 +22955,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of JAVA_HOME_PROCESSED" "$LINENO" 5
-   fi
- 
-@@ -21140,8 +23004,8 @@ $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\",
- 
-   if test "x$path" != "x$new_path"; then
-     JAVA_HOME_PROCESSED="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -21178,8 +23042,8 @@ $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     JAVA_HOME_PROCESSED="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -21190,8 +23054,8 @@ $as_echo "$as_me: Rewriting JAVA_HOME_PROCESSED to \"$new_path\"" >&6;}
-     path="$JAVA_HOME_PROCESSED"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -21205,15 +23069,15 @@ $as_echo "$as_me: The path of JAVA_HOME_PROCESSED, which resolves as \"$path\",
-   fi
- 
-     if test ! -d "$JAVA_HOME_PROCESSED"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
--$as_echo "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your JAVA_HOME points to a non-existing directory!" >&5
-+printf "%s\n" "$as_me: Your JAVA_HOME points to a non-existing directory!" >&6;}
-     else
-       # Aha, the user has set a JAVA_HOME
-       # let us use that as the Boot JDK.
-       BOOT_JDK="$JAVA_HOME_PROCESSED"
-       BOOT_JDK_FOUND=maybe
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
--$as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using JAVA_HOME" >&5
-+printf "%s\n" "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
-     fi
-   fi
- 
-@@ -21222,22 +23086,22 @@ $as_echo "$as_me: Found potential Boot JDK using JAVA_HOME" >&6;}
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -21246,10 +23110,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -21274,8 +23138,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -21323,8 +23187,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -21361,8 +23225,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -21373,8 +23237,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -21387,15 +23251,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -21412,8 +23276,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-   if test -x /usr/libexec/java_home; then
-     BOOT_JDK=`/usr/libexec/java_home`
-     BOOT_JDK_FOUND=maybe
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home" >&5
--$as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using /usr/libexec/java_home" >&5
-+printf "%s\n" "$as_me: Found potential Boot JDK using /usr/libexec/java_home" >&6;}
-   fi
- 
- 
-@@ -21421,22 +23285,22 @@ $as_echo "$as_me: Found potential Boot JDK using /usr/libexec/java_home" >&6;}
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -21445,10 +23309,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -21473,8 +23337,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -21522,8 +23386,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -21560,8 +23424,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -21572,8 +23436,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -21586,15 +23450,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -21610,12 +23474,13 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
- 
-   # Extract the first word of "javac", so it can be a program name with args.
- set dummy javac; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_JAVAC_CHECK+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $JAVAC_CHECK in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_JAVAC_CHECK+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $JAVAC_CHECK in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_JAVAC_CHECK="$JAVAC_CHECK" # Let the user override the test with a path.
-   ;;
-@@ -21624,11 +23489,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_JAVAC_CHECK="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_JAVAC_CHECK="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -21636,26 +23505,28 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- JAVAC_CHECK=$ac_cv_path_JAVAC_CHECK
- if test -n "$JAVAC_CHECK"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
--$as_echo "$JAVAC_CHECK" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAVAC_CHECK" >&5
-+printf "%s\n" "$JAVAC_CHECK" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-   # Extract the first word of "java", so it can be a program name with args.
- set dummy java; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_JAVA_CHECK+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $JAVA_CHECK in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_JAVA_CHECK+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $JAVA_CHECK in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_JAVA_CHECK="$JAVA_CHECK" # Let the user override the test with a path.
-   ;;
-@@ -21664,11 +23535,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_JAVA_CHECK="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_JAVA_CHECK="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -21676,15 +23551,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- JAVA_CHECK=$ac_cv_path_JAVA_CHECK
- if test -n "$JAVA_CHECK"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
--$as_echo "$JAVA_CHECK" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JAVA_CHECK" >&5
-+printf "%s\n" "$JAVA_CHECK" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -21750,8 +23626,8 @@ fi
-     if test -x "$BOOT_JDK/bin/javac" && test -x "$BOOT_JDK/bin/java"; then
-       # Looks like we found ourselves an JDK
-       BOOT_JDK_FOUND=maybe
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
--$as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using java(c) in PATH" >&5
-+printf "%s\n" "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
-     fi
-   fi
- 
-@@ -21760,22 +23636,22 @@ $as_echo "$as_me: Found potential Boot JDK using java(c) in PATH" >&6;}
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -21784,10 +23660,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -21812,8 +23688,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -21861,8 +23737,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -21899,8 +23775,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -21911,8 +23787,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -21925,15 +23801,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -21977,8 +23853,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
-         if test -d "$BOOT_JDK"; then
-           BOOT_JDK_FOUND=maybe
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
--$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
-+printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-         fi
- 
- 
-@@ -21986,22 +23862,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -22010,10 +23886,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -22038,8 +23914,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -22087,8 +23963,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -22125,8 +24001,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -22137,8 +24013,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -22151,15 +24027,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -22177,22 +24053,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -22201,10 +24077,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -22229,8 +24105,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -22278,8 +24154,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -22316,8 +24192,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -22328,8 +24204,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -22342,15 +24218,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -22387,8 +24263,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
-         if test -d "$BOOT_JDK"; then
-           BOOT_JDK_FOUND=maybe
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
--$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
-+printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-         fi
- 
- 
-@@ -22396,22 +24272,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -22420,10 +24296,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -22448,8 +24324,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -22497,8 +24373,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -22535,8 +24411,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -22547,8 +24423,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -22561,15 +24437,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -22587,22 +24463,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -22611,10 +24487,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -22639,8 +24515,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -22688,8 +24564,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -22726,8 +24602,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -22738,8 +24614,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -22752,15 +24628,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -22797,8 +24673,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
-         if test -d "$BOOT_JDK"; then
-           BOOT_JDK_FOUND=maybe
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
--$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
-+printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-         fi
- 
- 
-@@ -22806,22 +24682,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -22830,10 +24706,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -22858,8 +24734,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -22907,8 +24783,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -22945,8 +24821,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -22957,8 +24833,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -22971,15 +24847,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -22997,22 +24873,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -23021,10 +24897,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -23049,8 +24925,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -23098,8 +24974,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -23136,8 +25012,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -23148,8 +25024,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -23162,15 +25038,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -23207,8 +25083,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
-         if test -d "$BOOT_JDK"; then
-           BOOT_JDK_FOUND=maybe
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
--$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
-+printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-         fi
- 
- 
-@@ -23216,22 +25092,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -23240,10 +25116,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -23268,8 +25144,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -23317,8 +25193,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -23355,8 +25231,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -23367,8 +25243,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -23381,15 +25257,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -23407,22 +25283,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -23431,10 +25307,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -23459,8 +25335,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -23508,8 +25384,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -23546,8 +25422,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -23558,8 +25434,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -23572,15 +25448,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -23604,8 +25480,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
-         if test -d "$BOOT_JDK"; then
-           BOOT_JDK_FOUND=maybe
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
--$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
-+printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-         fi
- 
- 
-@@ -23613,22 +25489,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -23637,10 +25513,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -23665,8 +25541,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -23714,8 +25590,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -23752,8 +25628,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -23764,8 +25640,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -23778,15 +25654,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -23802,22 +25678,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -23826,10 +25702,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -23854,8 +25730,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -23903,8 +25779,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -23941,8 +25817,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -23953,8 +25829,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -23967,15 +25843,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -24000,8 +25876,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
-         if test -d "$BOOT_JDK"; then
-           BOOT_JDK_FOUND=maybe
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
--$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
-+printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-         fi
- 
- 
-@@ -24009,22 +25885,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -24033,10 +25909,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -24061,8 +25937,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -24110,8 +25986,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -24148,8 +26024,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -24160,8 +26036,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -24174,15 +26050,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -24198,22 +26074,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -24222,10 +26098,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -24250,8 +26126,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -24299,8 +26175,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -24337,8 +26213,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -24349,8 +26225,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -24363,15 +26239,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -24395,8 +26271,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
-         if test -d "$BOOT_JDK"; then
-           BOOT_JDK_FOUND=maybe
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
--$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
-+printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-         fi
- 
- 
-@@ -24404,22 +26280,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -24428,10 +26304,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -24456,8 +26332,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -24505,8 +26381,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -24543,8 +26419,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -24555,8 +26431,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -24569,15 +26445,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -24593,22 +26469,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -24617,10 +26493,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -24645,8 +26521,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -24694,8 +26570,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -24732,8 +26608,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -24744,8 +26620,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -24758,15 +26634,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -24791,8 +26667,8 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-         BOOT_JDK="${BOOT_JDK_PREFIX}/${JDK_TO_TRY}${BOOT_JDK_SUFFIX}"
-         if test -d "$BOOT_JDK"; then
-           BOOT_JDK_FOUND=maybe
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
--$as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&5
-+printf "%s\n" "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_JDK_PREFIX/$JDK_TO_TRY)" >&6;}
-         fi
- 
- 
-@@ -24800,22 +26676,22 @@ $as_echo "$as_me: Found potential Boot JDK using well-known locations (in $BOOT_
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -24824,10 +26700,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -24852,8 +26728,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -24901,8 +26777,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -24939,8 +26815,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -24951,8 +26827,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -24965,15 +26841,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -24989,22 +26865,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -25013,10 +26889,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -25041,8 +26917,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -25090,8 +26966,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -25128,8 +27004,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -25140,8 +27016,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -25154,15 +27030,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -25177,22 +27053,22 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-     if test "x$BOOT_JDK_FOUND" = xmaybe; then
-       # Do we have a bin/java?
-       if test ! -x "$BOOT_JDK/bin/java"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/java; ignoring" >&6;}
-         BOOT_JDK_FOUND=no
-       else
-         # Do we have a bin/javac?
-         if test ! -x "$BOOT_JDK/bin/javac"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
--          { $as_echo "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
--$as_echo "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain bin/javac; ignoring" >&6;}
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (This might be an JRE instead of an JDK)" >&5
-+printf "%s\n" "$as_me: (This might be an JRE instead of an JDK)" >&6;}
-           BOOT_JDK_FOUND=no
-         else
-           # Do we have an rt.jar? (On MacOSX it is called classes.jar)
-           if test ! -f "$BOOT_JDK/jre/lib/rt.jar" && test ! -f "$BOOT_JDK/../Classes/classes.jar"; then
--            { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-+            { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.jar; ignoring" >&6;}
-             BOOT_JDK_FOUND=no
-           else
-             # Oh, this is looking good! We probably have found a proper JDK. Is it the correct version?
-@@ -25201,10 +27077,10 @@ $as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK did not contain an rt.ja
-             # Extra M4 quote needed to protect [] in grep expression.
-             FOUND_VERSION_78=`echo $BOOT_JDK_VERSION | grep  '\"1\.[78]\.'`
-             if test "x$FOUND_VERSION_78" = x; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
--$as_echo "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
--              { $as_echo "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
--$as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&5
-+printf "%s\n" "$as_me: Potential Boot JDK found at $BOOT_JDK is incorrect JDK version ($BOOT_JDK_VERSION); ignoring" >&6;}
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: (Your Boot JDK must be version 7 or 8)" >&5
-+printf "%s\n" "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-               BOOT_JDK_FOUND=no
-             else
-               # We're done! :-)
-@@ -25229,8 +27105,8 @@ $as_echo "$as_me: (Your Boot JDK must be version 7 or 8)" >&6;}
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of BOOT_JDK" "$LINENO" 5
-   fi
- 
-@@ -25278,8 +27154,8 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -25316,8 +27192,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     BOOT_JDK="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BOOT_JDK to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -25328,8 +27204,8 @@ $as_echo "$as_me: Rewriting BOOT_JDK to \"$new_path\"" >&6;}
-     path="$BOOT_JDK"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -25342,15 +27218,15 @@ $as_echo "$as_me: The path of BOOT_JDK, which resolves as \"$path\", is invalid.
-     BOOT_JDK="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
--$as_echo_n "checking for Boot JDK... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
--$as_echo "$BOOT_JDK" >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
--$as_echo_n "checking Boot JDK version... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Boot JDK" >&5
-+printf %s "checking for Boot JDK... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK" >&5
-+printf "%s\n" "$BOOT_JDK" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Boot JDK version" >&5
-+printf %s "checking Boot JDK version... " >&6; }
-               BOOT_JDK_VERSION=`"$BOOT_JDK/bin/java" -version 2>&1 | $TR '\n\r' '  '`
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
--$as_echo "$BOOT_JDK_VERSION" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_VERSION" >&5
-+printf "%s\n" "$BOOT_JDK_VERSION" >&6; }
-             fi # end check jdk version
-           fi # end check rt.jar
-         fi # end check javac
-@@ -25391,10 +27267,10 @@ $as_echo "$BOOT_JDK_VERSION" >&6; }
-     fi
-   fi
- 
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find a valid Boot JDK. $HELP_MSG" >&5
--$as_echo "$as_me: Could not find a valid Boot JDK. $HELP_MSG" >&6;}
--    { $as_echo "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5
--$as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find a valid Boot JDK. $HELP_MSG" >&5
-+printf "%s\n" "$as_me: Could not find a valid Boot JDK. $HELP_MSG" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be fixed by explicitely setting --with-boot-jdk" >&5
-+printf "%s\n" "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-     as_fn_error $? "Cannot continue" "$LINENO" 5
-   fi
- 
-@@ -25416,102 +27292,102 @@ $as_echo "$as_me: This might be fixed by explicitely setting --with-boot-jdk" >&
- 
-   # Setup tools from the Boot JDK.
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for java in Boot JDK" >&5
--$as_echo_n "checking for java in Boot JDK... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for java in Boot JDK" >&5
-+printf %s "checking for java in Boot JDK... " >&6; }
-   JAVA=$BOOT_JDK/bin/java
-   if test ! -x $JAVA; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
--$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
-+printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-     as_fn_error $? "Could not find java in the Boot JDK" "$LINENO" 5
-   fi
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for javac in Boot JDK" >&5
--$as_echo_n "checking for javac in Boot JDK... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for javac in Boot JDK" >&5
-+printf %s "checking for javac in Boot JDK... " >&6; }
-   JAVAC=$BOOT_JDK/bin/javac
-   if test ! -x $JAVAC; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
--$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
-+printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-     as_fn_error $? "Could not find javac in the Boot JDK" "$LINENO" 5
-   fi
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for javah in Boot JDK" >&5
--$as_echo_n "checking for javah in Boot JDK... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for javah in Boot JDK" >&5
-+printf %s "checking for javah in Boot JDK... " >&6; }
-   JAVAH=$BOOT_JDK/bin/javah
-   if test ! -x $JAVAH; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
--$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
-+printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-     as_fn_error $? "Could not find javah in the Boot JDK" "$LINENO" 5
-   fi
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for javap in Boot JDK" >&5
--$as_echo_n "checking for javap in Boot JDK... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for javap in Boot JDK" >&5
-+printf %s "checking for javap in Boot JDK... " >&6; }
-   JAVAP=$BOOT_JDK/bin/javap
-   if test ! -x $JAVAP; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
--$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
-+printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-     as_fn_error $? "Could not find javap in the Boot JDK" "$LINENO" 5
-   fi
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jar in Boot JDK" >&5
--$as_echo_n "checking for jar in Boot JDK... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for jar in Boot JDK" >&5
-+printf %s "checking for jar in Boot JDK... " >&6; }
-   JAR=$BOOT_JDK/bin/jar
-   if test ! -x $JAR; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
--$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
-+printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-     as_fn_error $? "Could not find jar in the Boot JDK" "$LINENO" 5
-   fi
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for rmic in Boot JDK" >&5
--$as_echo_n "checking for rmic in Boot JDK... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for rmic in Boot JDK" >&5
-+printf %s "checking for rmic in Boot JDK... " >&6; }
-   RMIC=$BOOT_JDK/bin/rmic
-   if test ! -x $RMIC; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
--$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
-+printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-     as_fn_error $? "Could not find rmic in the Boot JDK" "$LINENO" 5
-   fi
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for native2ascii in Boot JDK" >&5
--$as_echo_n "checking for native2ascii in Boot JDK... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for native2ascii in Boot JDK" >&5
-+printf %s "checking for native2ascii in Boot JDK... " >&6; }
-   NATIVE2ASCII=$BOOT_JDK/bin/native2ascii
-   if test ! -x $NATIVE2ASCII; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
--$as_echo "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&5
-+printf "%s\n" "$as_me: Your Boot JDK seems broken. This might be fixed by explicitely setting --with-boot-jdk" >&6;}
-     as_fn_error $? "Could not find native2ascii in the Boot JDK" "$LINENO" 5
-   fi
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
- 
- 
-   # Finally, set some other options...
-@@ -25527,10 +27403,10 @@ $as_echo "ok" >&6; }
-   else
-     BOOT_JDK_BITS="32"
-   fi
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if Boot JDK is 32 or 64 bits" >&5
--$as_echo_n "checking if Boot JDK is 32 or 64 bits... " >&6; }
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_BITS" >&5
--$as_echo "$BOOT_JDK_BITS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if Boot JDK is 32 or 64 bits" >&5
-+printf %s "checking if Boot JDK is 32 or 64 bits... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BOOT_JDK_BITS" >&5
-+printf "%s\n" "$BOOT_JDK_BITS" >&6; }
- 
- 
- 
-@@ -25540,13 +27416,14 @@ $as_echo "$BOOT_JDK_BITS" >&6; }
-   #
- 
- # Check whether --with-boot-jdk-jvmargs was given.
--if test "${with_boot_jdk_jvmargs+set}" = set; then :
-+if test ${with_boot_jdk_jvmargs+y}
-+then :
-   withval=$with_boot_jdk_jvmargs;
- fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command " >&5
--$as_echo_n "checking flags for boot jdk java command ... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command " >&5
-+printf %s "checking flags for boot jdk java command ... " >&6; }
- 
-   # Disable special log output when a debug build is used as Boot JDK...
- 
-@@ -25582,16 +27459,16 @@ $as_echo_n "checking flags for boot jdk java command ... " >&6; }
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs" >&5
--$as_echo "$boot_jdk_jvmargs" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs" >&5
-+printf "%s\n" "$boot_jdk_jvmargs" >&6; }
- 
-   # For now, general JAVA_FLAGS are the same as the boot jdk jvmargs
-   JAVA_FLAGS=$boot_jdk_jvmargs
- 
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for big workloads" >&5
--$as_echo_n "checking flags for boot jdk java command for big workloads... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for big workloads" >&5
-+printf %s "checking flags for boot jdk java command for big workloads... " >&6; }
- 
-   # Starting amount of heap memory.
- 
-@@ -25684,15 +27561,15 @@ $as_echo_n "checking flags for boot jdk java command for big workloads... " >&6;
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_big" >&5
--$as_echo "$boot_jdk_jvmargs_big" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_big" >&5
-+printf "%s\n" "$boot_jdk_jvmargs_big" >&6; }
- 
-   JAVA_FLAGS_BIG=$boot_jdk_jvmargs_big
- 
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for small workloads" >&5
--$as_echo_n "checking flags for boot jdk java command for small workloads... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking flags for boot jdk java command for small workloads" >&5
-+printf %s "checking flags for boot jdk java command for small workloads... " >&6; }
- 
-   # Use serial gc for small short lived tools if possible
- 
-@@ -25741,8 +27618,8 @@ $as_echo_n "checking flags for boot jdk java command for small workloads... " >&
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_small" >&5
--$as_echo "$boot_jdk_jvmargs_small" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $boot_jdk_jvmargs_small" >&5
-+printf "%s\n" "$boot_jdk_jvmargs_small" >&6; }
- 
-   JAVA_FLAGS_SMALL=$boot_jdk_jvmargs_small
- 
-@@ -25781,21 +27658,24 @@ $as_echo "$boot_jdk_jvmargs_small" >&6; }
-   #
- 
- # Check whether --with-add-source-root was given.
--if test "${with_add_source_root+set}" = set; then :
-+if test ${with_add_source_root+y}
-+then :
-   withval=$with_add_source_root;
- fi
- 
- 
- 
- # Check whether --with-override-source-root was given.
--if test "${with_override_source_root+set}" = set; then :
-+if test ${with_override_source_root+y}
-+then :
-   withval=$with_override_source_root;
- fi
- 
- 
- 
- # Check whether --with-adds-and-overrides was given.
--if test "${with_adds_and_overrides+set}" = set; then :
-+if test ${with_adds_and_overrides+y}
-+then :
-   withval=$with_adds_and_overrides;
- fi
- 
-@@ -25892,49 +27772,56 @@ fi
- 
- 
- # Check whether --with-override-langtools was given.
--if test "${with_override_langtools+set}" = set; then :
-+if test ${with_override_langtools+y}
-+then :
-   withval=$with_override_langtools;
- fi
- 
- 
- 
- # Check whether --with-override-corba was given.
--if test "${with_override_corba+set}" = set; then :
-+if test ${with_override_corba+y}
-+then :
-   withval=$with_override_corba;
- fi
- 
- 
- 
- # Check whether --with-override-jaxp was given.
--if test "${with_override_jaxp+set}" = set; then :
-+if test ${with_override_jaxp+y}
-+then :
-   withval=$with_override_jaxp;
- fi
- 
- 
- 
- # Check whether --with-override-jaxws was given.
--if test "${with_override_jaxws+set}" = set; then :
-+if test ${with_override_jaxws+y}
-+then :
-   withval=$with_override_jaxws;
- fi
- 
- 
- 
- # Check whether --with-override-hotspot was given.
--if test "${with_override_hotspot+set}" = set; then :
-+if test ${with_override_hotspot+y}
-+then :
-   withval=$with_override_hotspot;
- fi
- 
- 
- 
- # Check whether --with-override-nashorn was given.
--if test "${with_override_nashorn+set}" = set; then :
-+if test ${with_override_nashorn+y}
-+then :
-   withval=$with_override_nashorn;
- fi
- 
- 
- 
- # Check whether --with-override-jdk was given.
--if test "${with_override_jdk+set}" = set; then :
-+if test ${with_override_jdk+y}
-+then :
-   withval=$with_override_jdk;
- fi
- 
-@@ -25947,10 +27834,10 @@ fi
-     if ! test -f $LANGTOOLS_TOPDIR/make/Makefile; then
-       as_fn_error $? "You have to override langtools with a full langtools repo!" "$LINENO" 5
-     fi
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if langtools should be overridden" >&5
--$as_echo_n "checking if langtools should be overridden... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $LANGTOOLS_TOPDIR" >&5
--$as_echo "yes with $LANGTOOLS_TOPDIR" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if langtools should be overridden" >&5
-+printf %s "checking if langtools should be overridden... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $LANGTOOLS_TOPDIR" >&5
-+printf "%s\n" "yes with $LANGTOOLS_TOPDIR" >&6; }
-   fi
-   if test "x$with_override_corba" != x; then
-     CURDIR="$PWD"
-@@ -25960,10 +27847,10 @@ $as_echo "yes with $LANGTOOLS_TOPDIR" >&6; }
-     if ! test -f $CORBA_TOPDIR/make/Makefile; then
-       as_fn_error $? "You have to override corba with a full corba repo!" "$LINENO" 5
-     fi
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if corba should be overridden" >&5
--$as_echo_n "checking if corba should be overridden... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $CORBA_TOPDIR" >&5
--$as_echo "yes with $CORBA_TOPDIR" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if corba should be overridden" >&5
-+printf %s "checking if corba should be overridden... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $CORBA_TOPDIR" >&5
-+printf "%s\n" "yes with $CORBA_TOPDIR" >&6; }
-   fi
-   if test "x$with_override_jaxp" != x; then
-     CURDIR="$PWD"
-@@ -25973,10 +27860,10 @@ $as_echo "yes with $CORBA_TOPDIR" >&6; }
-     if ! test -f $JAXP_TOPDIR/make/Makefile; then
-       as_fn_error $? "You have to override jaxp with a full jaxp repo!" "$LINENO" 5
-     fi
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if jaxp should be overridden" >&5
--$as_echo_n "checking if jaxp should be overridden... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $JAXP_TOPDIR" >&5
--$as_echo "yes with $JAXP_TOPDIR" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if jaxp should be overridden" >&5
-+printf %s "checking if jaxp should be overridden... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $JAXP_TOPDIR" >&5
-+printf "%s\n" "yes with $JAXP_TOPDIR" >&6; }
-   fi
-   if test "x$with_override_jaxws" != x; then
-     CURDIR="$PWD"
-@@ -25986,10 +27873,10 @@ $as_echo "yes with $JAXP_TOPDIR" >&6; }
-     if ! test -f $JAXWS_TOPDIR/make/Makefile; then
-       as_fn_error $? "You have to override jaxws with a full jaxws repo!" "$LINENO" 5
-     fi
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if jaxws should be overridden" >&5
--$as_echo_n "checking if jaxws should be overridden... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $JAXWS_TOPDIR" >&5
--$as_echo "yes with $JAXWS_TOPDIR" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if jaxws should be overridden" >&5
-+printf %s "checking if jaxws should be overridden... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $JAXWS_TOPDIR" >&5
-+printf "%s\n" "yes with $JAXWS_TOPDIR" >&6; }
-   fi
-   if test "x$with_override_hotspot" != x; then
-     CURDIR="$PWD"
-@@ -25999,10 +27886,10 @@ $as_echo "yes with $JAXWS_TOPDIR" >&6; }
-     if ! test -f $HOTSPOT_TOPDIR/make/Makefile; then
-       as_fn_error $? "You have to override hotspot with a full hotspot repo!" "$LINENO" 5
-     fi
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if hotspot should be overridden" >&5
--$as_echo_n "checking if hotspot should be overridden... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $HOTSPOT_TOPDIR" >&5
--$as_echo "yes with $HOTSPOT_TOPDIR" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if hotspot should be overridden" >&5
-+printf %s "checking if hotspot should be overridden... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $HOTSPOT_TOPDIR" >&5
-+printf "%s\n" "yes with $HOTSPOT_TOPDIR" >&6; }
-   fi
-   if test "x$with_override_nashorn" != x; then
-     CURDIR="$PWD"
-@@ -26012,10 +27899,10 @@ $as_echo "yes with $HOTSPOT_TOPDIR" >&6; }
-     if ! test -f $NASHORN_TOPDIR/make/Makefile; then
-       as_fn_error $? "You have to override nashorn with a full nashorn repo!" "$LINENO" 5
-     fi
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if nashorn should be overridden" >&5
--$as_echo_n "checking if nashorn should be overridden... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $NASHORN_TOPDIR" >&5
--$as_echo "yes with $NASHORN_TOPDIR" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if nashorn should be overridden" >&5
-+printf %s "checking if nashorn should be overridden... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $NASHORN_TOPDIR" >&5
-+printf "%s\n" "yes with $NASHORN_TOPDIR" >&6; }
-   fi
-   if test "x$with_override_jdk" != x; then
-     CURDIR="$PWD"
-@@ -26025,10 +27912,10 @@ $as_echo "yes with $NASHORN_TOPDIR" >&6; }
-     if ! test -f $JDK_TOPDIR/make/Makefile; then
-       as_fn_error $? "You have to override JDK with a full JDK repo!" "$LINENO" 5
-     fi
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if JDK should be overridden" >&5
--$as_echo_n "checking if JDK should be overridden... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes with $JDK_TOPDIR" >&5
--$as_echo "yes with $JDK_TOPDIR" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if JDK should be overridden" >&5
-+printf %s "checking if JDK should be overridden... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes with $JDK_TOPDIR" >&5
-+printf "%s\n" "yes with $JDK_TOPDIR" >&6; }
-   fi
- 
- 
-@@ -26041,7 +27928,8 @@ $as_echo "yes with $JDK_TOPDIR" >&6; }
- 
- 
- # Check whether --with-import-hotspot was given.
--if test "${with_import_hotspot+set}" = set; then :
-+if test ${with_import_hotspot+y}
-+then :
-   withval=$with_import_hotspot;
- fi
- 
-@@ -26053,10 +27941,10 @@ fi
-     if ! (test -d $HOTSPOT_DIST/lib && test -d $HOTSPOT_DIST/jre/lib); then
-       as_fn_error $? "You have to import hotspot from a full jdk image or hotspot build dist dir!" "$LINENO" 5
-     fi
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if hotspot should be imported" >&5
--$as_echo_n "checking if hotspot should be imported... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes from $HOTSPOT_DIST" >&5
--$as_echo "yes from $HOTSPOT_DIST" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if hotspot should be imported" >&5
-+printf %s "checking if hotspot should be imported... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes from $HOTSPOT_DIST" >&5
-+printf "%s\n" "yes from $HOTSPOT_DIST" >&6; }
-     BUILD_HOTSPOT=false
-   fi
- 
-@@ -26074,7 +27962,8 @@ $as_echo "yes from $HOTSPOT_DIST" >&6; }
- 
- 
- # Check whether --with-toolchain-type was given.
--if test "${with_toolchain_type+set}" = set; then :
-+if test ${with_toolchain_type+y}
-+then :
-   withval=$with_toolchain_type;
- fi
- 
-@@ -26093,8 +27982,8 @@ fi
-     XCODE_MAJOR_VERSION=`$ECHO $XCODE_VERSION_OUTPUT | \
-         $SED -e 's/^Xcode \([1-9][0-9.]*\)/\1/' | \
-         $CUT -f 1 -d .`
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Xcode major version: $XCODE_MAJOR_VERSION" >&5
--$as_echo "$as_me: Xcode major version: $XCODE_MAJOR_VERSION" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Xcode major version: $XCODE_MAJOR_VERSION" >&5
-+printf "%s\n" "$as_me: Xcode major version: $XCODE_MAJOR_VERSION" >&6;}
-     if test $XCODE_MAJOR_VERSION -ge 5; then
-         DEFAULT_TOOLCHAIN="clang"
-     else
-@@ -26107,8 +27996,8 @@ $as_echo "$as_me: Xcode major version: $XCODE_MAJOR_VERSION" >&6;}
- 
-   if test "x$with_toolchain_type" = xlist; then
-     # List all toolchains
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The following toolchains are valid on this platform:" >&5
--$as_echo "$as_me: The following toolchains are valid on this platform:" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The following toolchains are valid on this platform:" >&5
-+printf "%s\n" "$as_me: The following toolchains are valid on this platform:" >&6;}
-     for toolchain in $VALID_TOOLCHAINS; do
-       toolchain_var_name=TOOLCHAIN_DESCRIPTION_$toolchain
-       TOOLCHAIN_DESCRIPTION=${!toolchain_var_name}
-@@ -26119,10 +28008,10 @@ $as_echo "$as_me: The following toolchains are valid on this platform:" >&6;}
-   elif test "x$with_toolchain_type" != x; then
-     # User override; check that it is valid
-     if test "x${VALID_TOOLCHAINS/$with_toolchain_type/}" = "x${VALID_TOOLCHAINS}"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Toolchain type $with_toolchain_type is not valid on this platform." >&5
--$as_echo "$as_me: Toolchain type $with_toolchain_type is not valid on this platform." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Valid toolchains: $VALID_TOOLCHAINS." >&5
--$as_echo "$as_me: Valid toolchains: $VALID_TOOLCHAINS." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Toolchain type $with_toolchain_type is not valid on this platform." >&5
-+printf "%s\n" "$as_me: Toolchain type $with_toolchain_type is not valid on this platform." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Valid toolchains: $VALID_TOOLCHAINS." >&5
-+printf "%s\n" "$as_me: Valid toolchains: $VALID_TOOLCHAINS." >&6;}
-       as_fn_error $? "Cannot continue." "$LINENO" 5
-     fi
-     TOOLCHAIN_TYPE=$with_toolchain_type
-@@ -26186,11 +28075,11 @@ $as_echo "$as_me: Valid toolchains: $VALID_TOOLCHAINS." >&6;}
- 
- 
-   if test "x$TOOLCHAIN_TYPE" = "x$DEFAULT_TOOLCHAIN"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)" >&5
--$as_echo "$as_me: Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)" >&5
-+printf "%s\n" "$as_me: Using default toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION)" >&6;}
-   else
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&5
--$as_echo "$as_me: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&5
-+printf "%s\n" "$as_me: Using user selected toolchain $TOOLCHAIN_TYPE ($TOOLCHAIN_DESCRIPTION). Default toolchain is $DEFAULT_TOOLCHAIN." >&6;}
-   fi
- 
- 
-@@ -26223,12 +28112,13 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
-   # VS linker. This must be done before changing the PATH when looking for VS.
-   # Extract the first word of "link", so it can be a program name with args.
- set dummy link; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CYGWIN_LINK+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CYGWIN_LINK in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CYGWIN_LINK+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CYGWIN_LINK in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CYGWIN_LINK="$CYGWIN_LINK" # Let the user override the test with a path.
-   ;;
-@@ -26237,11 +28127,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CYGWIN_LINK="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CYGWIN_LINK="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -26249,28 +28143,29 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CYGWIN_LINK=$ac_cv_path_CYGWIN_LINK
- if test -n "$CYGWIN_LINK"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_LINK" >&5
--$as_echo "$CYGWIN_LINK" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CYGWIN_LINK" >&5
-+printf "%s\n" "$CYGWIN_LINK" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-   if test "x$CYGWIN_LINK" != x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the first found link.exe is actually the Cygwin link tool" >&5
--$as_echo_n "checking if the first found link.exe is actually the Cygwin link tool... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the first found link.exe is actually the Cygwin link tool" >&5
-+printf %s "checking if the first found link.exe is actually the Cygwin link tool... " >&6; }
-     "$CYGWIN_LINK" --version > /dev/null
-     if test $? -eq 0 ; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-       # This might be the VS linker. Don't exclude it later on.
-       CYGWIN_LINK=""
-     fi
-@@ -26280,15 +28175,16 @@ $as_echo "no" >&6; }
- 
- 
- # Check whether --with-toolchain-version was given.
--if test "${with_toolchain_version+set}" = set; then :
-+if test ${with_toolchain_version+y}
-+then :
-   withval=$with_toolchain_version;
- fi
- 
- 
-   if test "x$with_toolchain_version" = xlist; then
-     # List all toolchains
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The following toolchain versions are valid on this platform:" >&5
--$as_echo "$as_me: The following toolchain versions are valid on this platform:" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The following toolchain versions are valid on this platform:" >&5
-+printf "%s\n" "$as_me: The following toolchain versions are valid on this platform:" >&6;}
-     for version in $VALID_VS_VERSIONS; do
-       eval VS_DESCRIPTION=\${VS_DESCRIPTION_$version}
-       $PRINTF "  %-10s  %s\n" $version "$VS_DESCRIPTION"
-@@ -26348,16 +28244,16 @@ $as_echo "$as_me: The following toolchain versions are valid on this platform:"
-     done
-     IFS="$OLDIFS"
- 
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found devkit $VS_DESCRIPTION" >&5
--$as_echo "$as_me: Found devkit $VS_DESCRIPTION" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found devkit $VS_DESCRIPTION" >&5
-+printf "%s\n" "$as_me: Found devkit $VS_DESCRIPTION" >&6;}
- 
-   elif test "x$with_toolchain_version" != x; then
-     # User override; check that it is valid
-     if test "x${VALID_VS_VERSIONS/$with_toolchain_version/}" = "x${VALID_VS_VERSIONS}"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Visual Studio version $with_toolchain_version is not valid." >&5
--$as_echo "$as_me: Visual Studio version $with_toolchain_version is not valid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&5
--$as_echo "$as_me: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Visual Studio version $with_toolchain_version is not valid." >&5
-+printf "%s\n" "$as_me: Visual Studio version $with_toolchain_version is not valid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&5
-+printf "%s\n" "$as_me: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&6;}
-       as_fn_error $? "Cannot continue." "$LINENO" 5
-     fi
-     VS_VERSIONS_PROBE_LIST="$with_toolchain_version"
-@@ -26407,8 +28303,8 @@ $as_echo "$as_me: Valid Visual Studio versions: $VALID_VS_VERSIONS." >&6;}
-     fi
- 
-     if test -d "$VS_BASE"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
-         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
-       else
-@@ -26424,8 +28320,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
-       done
- 
-       if test "x$VS_ENV_CMD" = x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
--$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-       else
-         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
-         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
-@@ -26464,8 +28360,8 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
-     fi
- 
-     if test -d "$VS_BASE"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
-         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
-       else
-@@ -26481,8 +28377,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
-       done
- 
-       if test "x$VS_ENV_CMD" = x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
--$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-       else
-         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
-         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
-@@ -26496,12 +28392,12 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
-     if test "x$VS_ENV_CMD" = x; then
-       # Having specified an argument which is incorrect will produce an instant failure;
-       # we should not go on looking
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path given by --with-tools-dir does not contain a valid" >&5
--$as_echo "$as_me: The path given by --with-tools-dir does not contain a valid" >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&5
--$as_echo "$as_me: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: directory within the Visual Studio installation" >&5
--$as_echo "$as_me: directory within the Visual Studio installation" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path given by --with-tools-dir does not contain a valid" >&5
-+printf "%s\n" "$as_me: The path given by --with-tools-dir does not contain a valid" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&5
-+printf "%s\n" "$as_me: Visual Studio installation. Please point to the VC/bin or VC/bin/amd64" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: directory within the Visual Studio installation" >&5
-+printf "%s\n" "$as_me: directory within the Visual Studio installation" >&6;}
-       as_fn_error $? "Cannot locate a valid Visual Studio installation" "$LINENO" 5
-     fi
-   fi
-@@ -26537,8 +28433,8 @@ $as_echo "$as_me: directory within the Visual Studio installation" >&6;}
-     fi
- 
-     if test -d "$VS_BASE"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
-         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
-       else
-@@ -26554,8 +28450,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
-       done
- 
-       if test "x$VS_ENV_CMD" = x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
--$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-       else
-         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
-         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
-@@ -26596,8 +28492,8 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
-     fi
- 
-     if test -d "$VS_BASE"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
-         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
-       else
-@@ -26613,8 +28509,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
-       done
- 
-       if test "x$VS_ENV_CMD" = x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
--$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-       else
-         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
-         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
-@@ -26657,8 +28553,8 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
-     fi
- 
-     if test -d "$VS_BASE"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
-         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
-       else
-@@ -26674,8 +28570,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
-       done
- 
-       if test "x$VS_ENV_CMD" = x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
--$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-       else
-         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
-         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
-@@ -26715,8 +28611,8 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
-     fi
- 
-     if test -d "$VS_BASE"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
-         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
-       else
-@@ -26732,8 +28628,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
-       done
- 
-       if test "x$VS_ENV_CMD" = x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
--$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-       else
-         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
-         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
-@@ -26772,8 +28668,8 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
-     fi
- 
-     if test -d "$VS_BASE"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Visual Studio installation at $VS_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&6;}
-       if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
-         VCVARSFILES="vc/bin/vcvars32.bat vc/auxiliary/build/vcvars32.bat"
-       else
-@@ -26789,8 +28685,8 @@ $as_echo "$as_me: Found Visual Studio installation at $VS_BASE using $METHOD" >&
-       done
- 
-       if test "x$VS_ENV_CMD" = x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
--$as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio installation not recognized. Ignoring" >&6;}
-       else
-         # PLATFORM_TOOLSET is used during the compilation of the freetype sources
-         # (see 'LIB_BUILD_FREETYPE' in libraries.m4) and must be one of 'v100',
-@@ -26823,13 +28719,13 @@ $as_echo "$as_me: Warning: None of $VCVARSFILES were found, Visual Studio instal
-       # There have been cases of partial or broken SDK installations. A missing
-       # lib dir is not going to work.
-       if test ! -d "$WIN_SDK_BASE/lib"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
--$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
-       elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-         VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
-         if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
-           VS_ENV_ARGS="/x86"
-@@ -26841,10 +28737,10 @@ $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD"
-         # TODO: improve detection for other versions of SDK
-         eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
-       else
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
--$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
-       fi
-     fi
-   fi
-@@ -26870,13 +28766,13 @@ $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignori
-       # There have been cases of partial or broken SDK installations. A missing
-       # lib dir is not going to work.
-       if test ! -d "$WIN_SDK_BASE/lib"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
--$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
-       elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-         VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
-         if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
-           VS_ENV_ARGS="/x86"
-@@ -26888,10 +28784,10 @@ $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD"
-         # TODO: improve detection for other versions of SDK
-         eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
-       else
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
--$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
-       fi
-     fi
-   fi
-@@ -26917,13 +28813,13 @@ $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignori
-       # There have been cases of partial or broken SDK installations. A missing
-       # lib dir is not going to work.
-       if test ! -d "$WIN_SDK_BASE/lib"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
--$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
-       elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-         VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
-         if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
-           VS_ENV_ARGS="/x86"
-@@ -26935,10 +28831,10 @@ $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD"
-         # TODO: improve detection for other versions of SDK
-         eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
-       else
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
--$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
-       fi
-     fi
-   fi
-@@ -26963,13 +28859,13 @@ $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignori
-       # There have been cases of partial or broken SDK installations. A missing
-       # lib dir is not going to work.
-       if test ! -d "$WIN_SDK_BASE/lib"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
--$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
-       elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-         VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
-         if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
-           VS_ENV_ARGS="/x86"
-@@ -26981,10 +28877,10 @@ $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD"
-         # TODO: improve detection for other versions of SDK
-         eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
-       else
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
--$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
-       fi
-     fi
-   fi
-@@ -27008,13 +28904,13 @@ $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignori
-       # There have been cases of partial or broken SDK installations. A missing
-       # lib dir is not going to work.
-       if test ! -d "$WIN_SDK_BASE/lib"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
--$as_echo "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, lib dir is missing. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: Installation is broken, lib dir is missing. Ignoring" >&6;}
-       elif test -f "$WIN_SDK_BASE/Bin/SetEnv.Cmd"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-         VS_ENV_CMD="$WIN_SDK_BASE/Bin/SetEnv.Cmd"
-         if test "x$OPENJDK_TARGET_CPU_BITS" = x32; then
-           VS_ENV_ARGS="/x86"
-@@ -27026,10 +28922,10 @@ $as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD"
-         # TODO: improve detection for other versions of SDK
-         eval PLATFORM_TOOLSET="\${VS_SDK_PLATFORM_NAME_${VS_VERSION}}"
-       else
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
--$as_echo "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
--$as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&5
-+printf "%s\n" "$as_me: Found Windows SDK installation at $WIN_SDK_BASE using $METHOD" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&5
-+printf "%s\n" "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignoring" >&6;}
-       fi
-     fi
-   fi
-@@ -27045,8 +28941,8 @@ $as_echo "$as_me: Warning: Installation is broken, SetEnv.Cmd is missing. Ignori
-       eval MSVCP_NAME="\${VS_MSVCP_${VS_VERSION}}"
-       eval USE_UCRT="\${VS_USE_UCRT_${VS_VERSION}}"
-       # The rest of the variables are already evaled while probing
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found $VS_DESCRIPTION" >&5
--$as_echo "$as_me: Found $VS_DESCRIPTION" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $VS_DESCRIPTION" >&5
-+printf "%s\n" "$as_me: Found $VS_DESCRIPTION" >&6;}
-       break
-     fi
-   done
-@@ -27102,12 +28998,12 @@ $as_echo "$as_me: Found $VS_DESCRIPTION" >&6;}
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
-     fi
-@@ -27129,10 +29025,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of VS_ENV_CMD, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
-     fi
-   else
-@@ -27242,12 +29138,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
-     fi
-@@ -27319,12 +29215,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of VS_ENV_CMD, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of VS_ENV_CMD" "$LINENO" 5
-     fi
-@@ -27339,14 +29235,14 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     VS_ENV_CMD="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting VS_ENV_CMD to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting VS_ENV_CMD to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting VS_ENV_CMD to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting VS_ENV_CMD to \"$new_complete\"" >&6;}
-   fi
- 
- 
-       # Lets extract the variables that are set by vcvarsall.bat/vsvars32.bat/vsvars64.bat
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Trying to extract Visual Studio environment variables" >&5
--$as_echo "$as_me: Trying to extract Visual Studio environment variables" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Trying to extract Visual Studio environment variables" >&5
-+printf "%s\n" "$as_me: Trying to extract Visual Studio environment variables" >&6;}
- 
-       # We need to create a couple of temporary files.
-       VS_ENV_TMP_DIR="$OUTPUT_ROOT/vs-env"
-@@ -27412,42 +29308,42 @@ $as_echo "$as_me: Trying to extract Visual Studio environment variables" >&6;}
-       cd $CURDIR
- 
-       if test ! -s $VS_ENV_TMP_DIR/set-vs-env.sh; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Could not succesfully extract the envionment variables needed for the VS setup." >&5
--$as_echo "$as_me: Could not succesfully extract the envionment variables needed for the VS setup." >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
--$as_echo "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
--$as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not succesfully extract the envionment variables needed for the VS setup." >&5
-+printf "%s\n" "$as_me: Could not succesfully extract the envionment variables needed for the VS setup." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
-+printf "%s\n" "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
-+printf "%s\n" "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
-         as_fn_error $? "Cannot continue" "$LINENO" 5
-       fi
- 
-       # Now set all paths and other env variables. This will allow the rest of
-       # the configure script to find and run the compiler in the proper way.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Setting extracted environment variables" >&5
--$as_echo "$as_me: Setting extracted environment variables" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Setting extracted environment variables" >&5
-+printf "%s\n" "$as_me: Setting extracted environment variables" >&6;}
-       . $VS_ENV_TMP_DIR/set-vs-env.sh
-       # Now we have VS_PATH, VS_INCLUDE, VS_LIB. For further checking, we
-       # also define VCINSTALLDIR, WindowsSdkDir and WINDOWSSDKDIR.
-     else
-       # We did not find a vsvars bat file, let's hope we are run from a VS command prompt.
--     { $as_echo "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio installation, checking current environment" >&5
--$as_echo "$as_me: Cannot locate a valid Visual Studio installation, checking current environment" >&6;}
-+     { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio installation, checking current environment" >&5
-+printf "%s\n" "$as_me: Cannot locate a valid Visual Studio installation, checking current environment" >&6;}
-     fi
-   fi
- 
-   # At this point, we should have correct variables in the environment, or we can't continue.
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for Visual Studio variables" >&5
--$as_echo_n "checking for Visual Studio variables... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Visual Studio variables" >&5
-+printf %s "checking for Visual Studio variables... " >&6; }
- 
-   if test "x$VCINSTALLDIR" != x || test "x$WindowsSDKDir" != x \
-       || test "x$WINDOWSSDKDIR" != x || test "x$DEVKIT_NAME" != x; then
-     if test "x$VS_INCLUDE" = x || test "x$VS_LIB" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: present but broken" >&5
--$as_echo "present but broken" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: present but broken" >&5
-+printf "%s\n" "present but broken" >&6; }
-       as_fn_error $? "Your VC command prompt seems broken, INCLUDE and/or LIB is missing." "$LINENO" 5
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       # Remove any trailing "\" and " " from the variables.
-       VS_INCLUDE=`$ECHO "$VS_INCLUDE" | $SED 's/\\\\* *$//'`
-       VS_LIB=`$ECHO "$VS_LIB" | $SED 's/\\\\* *$//'`
-@@ -27466,22 +29362,22 @@ $as_echo "ok" >&6; }
- 
-     fi
-   else
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
- 
-     if test "x$VS_ENV_CMD" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio or Windows SDK installation on disk," >&5
--$as_echo "$as_me: Cannot locate a valid Visual Studio or Windows SDK installation on disk," >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: nor is this script run from a Visual Studio command prompt." >&5
--$as_echo "$as_me: nor is this script run from a Visual Studio command prompt." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Cannot locate a valid Visual Studio or Windows SDK installation on disk," >&5
-+printf "%s\n" "$as_me: Cannot locate a valid Visual Studio or Windows SDK installation on disk," >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: nor is this script run from a Visual Studio command prompt." >&5
-+printf "%s\n" "$as_me: nor is this script run from a Visual Studio command prompt." >&6;}
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Running the extraction script failed." >&5
--$as_echo "$as_me: Running the extraction script failed." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Running the extraction script failed." >&5
-+printf "%s\n" "$as_me: Running the extraction script failed." >&6;}
-     fi
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
--$as_echo "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
--    { $as_echo "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
--$as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&5
-+printf "%s\n" "$as_me: Try setting --with-tools-dir to the VC/bin directory within the VS installation" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&5
-+printf "%s\n" "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run configure from there." >&6;}
-     as_fn_error $? "Cannot continue" "$LINENO" 5
-   fi
- 
-@@ -27504,8 +29400,8 @@ $as_echo "$as_me: or run \"bash.exe -l\" from a VS command prompt and then run c
-     fi
- 
-     # DEVELOPER_DIR could also be provided directly
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking Determining if we need to set DEVELOPER_DIR" >&5
--$as_echo_n "checking Determining if we need to set DEVELOPER_DIR... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Determining if we need to set DEVELOPER_DIR" >&5
-+printf %s "checking Determining if we need to set DEVELOPER_DIR... " >&6; }
-     if test -n "$DEVELOPER_DIR"; then
-       if test ! -d "$DEVELOPER_DIR"; then
-         as_fn_error $? "Xcode Developer path does not exist: $DEVELOPER_DIR, please provide a path to the Xcode application bundle using --with-xcode-path" "$LINENO" 5
-@@ -27516,22 +29412,23 @@ $as_echo_n "checking Determining if we need to set DEVELOPER_DIR... " >&6; }
-       # make it visible to all the tools immediately
-       export DEVELOPER_DIR
-       SET_DEVELOPER_DIR="export DEVELOPER_DIR := $DEVELOPER_DIR"
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes ($DEVELOPER_DIR)" >&5
--$as_echo "yes ($DEVELOPER_DIR)" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes ($DEVELOPER_DIR)" >&5
-+printf "%s\n" "yes ($DEVELOPER_DIR)" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-     fi
- 
- 
-     # Extract the first word of "xcodebuild", so it can be a program name with args.
- set dummy xcodebuild; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_XCODEBUILD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $XCODEBUILD in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_XCODEBUILD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $XCODEBUILD in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_XCODEBUILD="$XCODEBUILD" # Let the user override the test with a path.
-   ;;
-@@ -27540,11 +29437,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_XCODEBUILD="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_XCODEBUILD="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -27552,15 +29453,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- XCODEBUILD=$ac_cv_path_XCODEBUILD
- if test -n "$XCODEBUILD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
--$as_echo "$XCODEBUILD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $XCODEBUILD" >&5
-+printf "%s\n" "$XCODEBUILD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -27573,23 +29475,23 @@ fi
-     if test -L "/usr/bin/gcc" -o -L "/usr/bin/g++"; then
-       # use xcrun to find the real gcc and add it's directory to PATH
-       # then autoconf magic will find it
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Found gcc symlinks to clang in /usr/bin, adding path to real gcc to PATH" >&5
--$as_echo "$as_me: Found gcc symlinks to clang in /usr/bin, adding path to real gcc to PATH" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found gcc symlinks to clang in /usr/bin, adding path to real gcc to PATH" >&5
-+printf "%s\n" "$as_me: Found gcc symlinks to clang in /usr/bin, adding path to real gcc to PATH" >&6;}
-       XCODE_BIN_PATH=$(dirname `xcrun -find gcc`)
-       PATH="$XCODE_BIN_PATH":$PATH
-     fi
- 
-     # Determine appropriate SDKPATH, don't use SDKROOT as it interferes with the stub tools
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking Determining Xcode SDK path" >&5
--$as_echo_n "checking Determining Xcode SDK path... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking Determining Xcode SDK path" >&5
-+printf %s "checking Determining Xcode SDK path... " >&6; }
-     # allow SDKNAME to be set to override the default SDK selection
-     SDKPATH=`"$XCODEBUILD" -sdk ${SDKNAME:-macosx} -version | grep '^Path: ' | sed 's/Path: //'`
-     if test -n "$SDKPATH"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SDKPATH" >&5
--$as_echo "$SDKPATH" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SDKPATH" >&5
-+printf "%s\n" "$SDKPATH" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: (none, will use system headers and frameworks)" >&5
--$as_echo "(none, will use system headers and frameworks)" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: (none, will use system headers and frameworks)" >&5
-+printf "%s\n" "(none, will use system headers and frameworks)" >&6; }
-     fi
- 
- 
-@@ -27630,6 +29532,21 @@ $as_echo "(none, will use system headers and frameworks)" >&6; }
-   fi
- 
- 
-+
-+
-+
-+
-+
-+
-+
-+
-+
-+
-+
-+
-+
-+
-+
-   #
-   # Setup the compilers (CC and CXX)
-   #
-@@ -27639,8 +29556,8 @@ $as_echo "(none, will use system headers and frameworks)" >&6; }
- 
-   if test "x$CC" != x; then
-     # User has supplied compiler name already, always let that override.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied compiler CC=$CC" >&5
--$as_echo "$as_me: Will use user supplied compiler CC=$CC" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied compiler CC=$CC" >&5
-+printf "%s\n" "$as_me: Will use user supplied compiler CC=$CC" >&6;}
-     if test "x`basename $CC`" = "x$CC"; then
-       # A command without a complete path is provided, search $PATH.
- 
-@@ -27648,12 +29565,13 @@ $as_echo "$as_me: Will use user supplied compiler CC=$CC" >&6;}
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_POTENTIAL_CC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $POTENTIAL_CC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_POTENTIAL_CC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $POTENTIAL_CC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_POTENTIAL_CC="$POTENTIAL_CC" # Let the user override the test with a path.
-   ;;
-@@ -27662,11 +29580,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_POTENTIAL_CC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_POTENTIAL_CC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -27674,15 +29596,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- POTENTIAL_CC=$ac_cv_path_POTENTIAL_CC
- if test -n "$POTENTIAL_CC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CC" >&5
--$as_echo "$POTENTIAL_CC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CC" >&5
-+printf "%s\n" "$POTENTIAL_CC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -27722,12 +29645,13 @@ done
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TOOLCHAIN_PATH_CC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TOOLCHAIN_PATH_CC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TOOLCHAIN_PATH_CC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TOOLCHAIN_PATH_CC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TOOLCHAIN_PATH_CC="$TOOLCHAIN_PATH_CC" # Let the user override the test with a path.
-   ;;
-@@ -27736,11 +29660,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TOOLCHAIN_PATH_CC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TOOLCHAIN_PATH_CC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -27748,15 +29676,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TOOLCHAIN_PATH_CC=$ac_cv_path_TOOLCHAIN_PATH_CC
- if test -n "$TOOLCHAIN_PATH_CC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH_CC" >&5
--$as_echo "$TOOLCHAIN_PATH_CC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH_CC" >&5
-+printf "%s\n" "$TOOLCHAIN_PATH_CC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -27774,12 +29703,13 @@ done
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_POTENTIAL_CC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $POTENTIAL_CC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_POTENTIAL_CC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $POTENTIAL_CC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_POTENTIAL_CC="$POTENTIAL_CC" # Let the user override the test with a path.
-   ;;
-@@ -27788,11 +29718,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_POTENTIAL_CC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_POTENTIAL_CC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -27800,15 +29734,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- POTENTIAL_CC=$ac_cv_path_POTENTIAL_CC
- if test -n "$POTENTIAL_CC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CC" >&5
--$as_echo "$POTENTIAL_CC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CC" >&5
-+printf "%s\n" "$POTENTIAL_CC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -27895,12 +29830,12 @@ done
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
-     fi
-@@ -27922,10 +29857,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of CC, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CC, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
-     fi
-   else
-@@ -28035,12 +29970,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
-     fi
-@@ -28112,12 +30047,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of CC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of CC" "$LINENO" 5
-     fi
-@@ -28132,14 +30067,14 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     CC="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CC to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting CC to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CC to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting CC to \"$new_complete\"" >&6;}
-   fi
- 
-   TEST_COMPILER="$CC"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking resolved symbolic links for CC" >&5
--$as_echo_n "checking resolved symbolic links for CC... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking resolved symbolic links for CC" >&5
-+printf %s "checking resolved symbolic links for CC... " >&6; }
-   SYMLINK_ORIGINAL="$TEST_COMPILER"
- 
-   if test "x$OPENJDK_BUILD_OS" != xwindows; then
-@@ -28190,17 +30125,17 @@ $as_echo_n "checking resolved symbolic links for CC... " >&6; }
-   fi
- 
-   if test "x$TEST_COMPILER" = "x$SYMLINK_ORIGINAL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no symlink" >&5
--$as_echo "no symlink" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no symlink" >&5
-+printf "%s\n" "no symlink" >&6; }
-   else
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYMLINK_ORIGINAL" >&5
--$as_echo "$SYMLINK_ORIGINAL" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if CC is disguised ccache" >&5
--$as_echo_n "checking if CC is disguised ccache... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SYMLINK_ORIGINAL" >&5
-+printf "%s\n" "$SYMLINK_ORIGINAL" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if CC is disguised ccache" >&5
-+printf %s "checking if CC is disguised ccache... " >&6; }
-     COMPILER_BASENAME=`$BASENAME "$SYMLINK_ORIGINAL"`
-     if test "x$COMPILER_BASENAME" = "xccache"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, trying to find proper $COMPILER_NAME compiler" >&5
--$as_echo "yes, trying to find proper $COMPILER_NAME compiler" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes, trying to find proper $COMPILER_NAME compiler" >&5
-+printf "%s\n" "yes, trying to find proper $COMPILER_NAME compiler" >&6; }
-       # We /usr/lib/ccache in the path, so cc is a symlink to /usr/bin/ccache.
-       # We want to control ccache invocation ourselves, so ignore this cc and try
-       # searching again.
-@@ -28215,38 +30150,44 @@ $as_echo "yes, trying to find proper $COMPILER_NAME compiler" >&6; }
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_PROPER_COMPILER_CC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$PROPER_COMPILER_CC"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_PROPER_COMPILER_CC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$PROPER_COMPILER_CC"; then
-   ac_cv_prog_PROPER_COMPILER_CC="$PROPER_COMPILER_CC" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_PROPER_COMPILER_CC="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- PROPER_COMPILER_CC=$ac_cv_prog_PROPER_COMPILER_CC
- if test -n "$PROPER_COMPILER_CC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CC" >&5
--$as_echo "$PROPER_COMPILER_CC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CC" >&5
-+printf "%s\n" "$PROPER_COMPILER_CC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -28259,38 +30200,44 @@ if test -z "$PROPER_COMPILER_CC"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_PROPER_COMPILER_CC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_PROPER_COMPILER_CC"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_PROPER_COMPILER_CC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_PROPER_COMPILER_CC"; then
-   ac_cv_prog_ac_ct_PROPER_COMPILER_CC="$ac_ct_PROPER_COMPILER_CC" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_PROPER_COMPILER_CC="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_PROPER_COMPILER_CC=$ac_cv_prog_ac_ct_PROPER_COMPILER_CC
- if test -n "$ac_ct_PROPER_COMPILER_CC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_PROPER_COMPILER_CC" >&5
--$as_echo "$ac_ct_PROPER_COMPILER_CC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_PROPER_COMPILER_CC" >&5
-+printf "%s\n" "$ac_ct_PROPER_COMPILER_CC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -28302,8 +30249,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     PROPER_COMPILER_CC=$ac_ct_PROPER_COMPILER_CC
-@@ -28351,12 +30298,12 @@ fi
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CC" "$LINENO" 5
-     fi
-@@ -28378,10 +30325,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CC" "$LINENO" 5
-     fi
-   else
-@@ -28491,12 +30438,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CC" "$LINENO" 5
-     fi
-@@ -28568,12 +30515,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of PROPER_COMPILER_CC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CC" "$LINENO" 5
-     fi
-@@ -28588,14 +30535,14 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     PROPER_COMPILER_CC="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting PROPER_COMPILER_CC to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting PROPER_COMPILER_CC to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting PROPER_COMPILER_CC to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting PROPER_COMPILER_CC to \"$new_complete\"" >&6;}
-   fi
- 
-       PATH="$RETRY_COMPILER_SAVED_PATH"
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for resolved symbolic links for CC" >&5
--$as_echo_n "checking for resolved symbolic links for CC... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for resolved symbolic links for CC" >&5
-+printf %s "checking for resolved symbolic links for CC... " >&6; }
- 
-   if test "x$OPENJDK_BUILD_OS" != xwindows; then
-     # Follow a chain of symbolic links. Use readlink
-@@ -28644,12 +30591,12 @@ $as_echo_n "checking for resolved symbolic links for CC... " >&6; }
-     fi
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CC" >&5
--$as_echo "$PROPER_COMPILER_CC" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CC" >&5
-+printf "%s\n" "$PROPER_COMPILER_CC" >&6; }
-       CC="$PROPER_COMPILER_CC"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, keeping CC" >&5
--$as_echo "no, keeping CC" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, keeping CC" >&5
-+printf "%s\n" "no, keeping CC" >&6; }
-     fi
-   fi
- 
-@@ -28665,12 +30612,12 @@ $as_echo "no, keeping CC" >&6; }
-     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null
-     if test $? -ne 0; then
-       ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
--$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
--$as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
--$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
-+printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
-+printf "%s\n" "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
-+printf "%s\n" "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
-       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
-     fi
-     # Remove usage instructions (if present), and
-@@ -28688,12 +30635,12 @@ $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUT
-     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
-     if test $? -ne 0; then
-       ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
--$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
--$as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
--$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
-+printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
-+printf "%s\n" "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
-+printf "%s\n" "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
-       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
-     fi
-     # Collapse compiler output into a single line
-@@ -28708,10 +30655,10 @@ $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUT
-     # Check that this is likely to be Microsoft CL.EXE.
-     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
-     if test $? -ne 0; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
--$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
--$as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
-+printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
-+printf "%s\n" "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
-       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
-     fi
-     # Collapse compiler output into a single line
-@@ -28728,10 +30675,10 @@ $as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\""
-     # Check that this is likely to be GCC.
-     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
-     if test $? -ne 0; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
--$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
--$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
-+printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
-+printf "%s\n" "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
-       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
-     fi
-     # Remove Copyright and legalese from version string, and
-@@ -28752,10 +30699,10 @@ $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSIO
-     # Check that this is likely to be clang
-     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
-     if test $? -ne 0; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
--$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
--$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
-+printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
-+printf "%s\n" "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
-       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
-     fi
-     # Collapse compiler output into a single line
-@@ -28771,8 +30718,8 @@ $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSIO
-   # This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
-   CC_VERSION_STRING="$COMPILER_VERSION_STRING"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
--$as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
-+printf "%s\n" "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
- 
- 
-   # Now that we have resolved CC ourself, let autoconf have its go at it
-@@ -28786,38 +30733,44 @@ if test -n "$ac_tool_prefix"; then
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_CC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$CC"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_CC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$CC"; then
-   ac_cv_prog_CC="$CC" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- CC=$ac_cv_prog_CC
- if test -n "$CC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
--$as_echo "$CC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
-+printf "%s\n" "$CC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -28830,38 +30783,44 @@ if test -z "$CC"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_CC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_CC"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_CC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_CC"; then
-   ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_CC="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_CC=$ac_cv_prog_ac_ct_CC
- if test -n "$ac_ct_CC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
--$as_echo "$ac_ct_CC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
-+printf "%s\n" "$ac_ct_CC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -28873,8 +30832,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     CC=$ac_ct_CC
-@@ -28882,23 +30841,23 @@ esac
- fi
- 
- 
--test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
--$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-+test -z "$CC" && { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
- as_fn_error $? "no acceptable C compiler found in \$PATH
--See \`config.log' for more details" "$LINENO" 5; }
-+See 'config.log' for more details" "$LINENO" 5; }
- 
- # Provide some information about the compiler.
--$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
-+printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
- set X $ac_compile
- ac_compiler=$2
--for ac_option in --version -v -V -qversion; do
-+for ac_option in --version -v -V -qversion -version; do
-   { { ac_try="$ac_compiler $ac_option >&5"
- case "(($ac_try" in
-   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_compiler $ac_option >&5") 2>conftest.err
-   ac_status=$?
-   if test -s conftest.err; then
-@@ -28908,7 +30867,7 @@ $as_echo "$ac_try_echo"; } >&5
-     cat conftest.er1 >&5
-   fi
-   rm -f conftest.er1 conftest.err
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; }
- done
- 
-@@ -28916,7 +30875,7 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-@@ -28928,9 +30887,9 @@ ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
- # Try to create an executable without -o first, disregard a.out.
- # It will help us diagnose broken compilers, and finding out an intuition
- # of exeext.
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
--$as_echo_n "checking whether the C compiler works... " >&6; }
--ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
-+printf %s "checking whether the C compiler works... " >&6; }
-+ac_link_default=`printf "%s\n" "$ac_link" | sed 's/ -o *conftest[^ ]*//'`
- 
- # The possible output files:
- ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
-@@ -28951,13 +30910,14 @@ case "(($ac_try" in
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_link_default") 2>&5
-   ac_status=$?
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
--  test $ac_status = 0; }; then :
--  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
--# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  test $ac_status = 0; }
-+then :
-+  # Autoconf-2.13 could set the ac_cv_exeext variable to 'no'.
-+# So ignore a value of 'no', otherwise this would lead to 'EXEEXT = no'
- # in a Makefile.  We should not override ac_cv_exeext if it was cached,
- # so that the user can short-circuit this test for compilers unknown to
- # Autoconf.
-@@ -28972,12 +30932,12 @@ do
- 	# certainly right.
- 	break;;
-     *.* )
--	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
-+	if test ${ac_cv_exeext+y} && test "$ac_cv_exeext" != no;
- 	then :; else
- 	   ac_cv_exeext=`expr "$ac_file" : '[^.]*\(\..*\)'`
- 	fi
- 	# We set ac_cv_exeext here because the later test for it is not
--	# safe: cross compilers may not add the suffix if given an `-o'
-+	# safe: cross compilers may not add the suffix if given an '-o'
- 	# argument, so we may need to know it at that point already.
- 	# Even if this section looks crufty: it has the advantage of
- 	# actually working.
-@@ -28988,48 +30948,52 @@ do
- done
- test "$ac_cv_exeext" = no && ac_cv_exeext=
- 
--else
--  ac_file=''
-+else case e in #(
-+  e) ac_file='' ;;
-+esac
- fi
--if test -z "$ac_file"; then :
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
--$as_echo "$as_me: failed program was:" >&5
-+if test -z "$ac_file"
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-+printf "%s\n" "$as_me: failed program was:" >&5
- sed 's/^/| /' conftest.$ac_ext >&5
- 
--{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
--$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-+{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
- as_fn_error 77 "C compiler cannot create executables
--See \`config.log' for more details" "$LINENO" 5; }
--else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+See 'config.log' for more details" "$LINENO" 5; }
-+else case e in #(
-+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; } ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
--$as_echo_n "checking for C compiler default output file name... " >&6; }
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
--$as_echo "$ac_file" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
-+printf %s "checking for C compiler default output file name... " >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
-+printf "%s\n" "$ac_file" >&6; }
- ac_exeext=$ac_cv_exeext
- 
- rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
- ac_clean_files=$ac_clean_files_save
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
--$as_echo_n "checking for suffix of executables... " >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
-+printf %s "checking for suffix of executables... " >&6; }
- if { { ac_try="$ac_link"
- case "(($ac_try" in
-   *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_link") 2>&5
-   ac_status=$?
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
--  test $ac_status = 0; }; then :
--  # If both `conftest.exe' and `conftest' are `present' (well, observable)
--# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
--# work properly (i.e., refer to `conftest.exe'), while it won't with
--# `rm'.
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  test $ac_status = 0; }
-+then :
-+  # If both 'conftest.exe' and 'conftest' are 'present' (well, observable)
-+# catch 'conftest.exe'.  For instance with Cygwin, 'ls conftest' will
-+# work properly (i.e., refer to 'conftest.exe'), while it won't with
-+# 'rm'.
- for ac_file in conftest.exe conftest conftest.*; do
-   test -f "$ac_file" || continue
-   case $ac_file in
-@@ -29039,15 +31003,16 @@ for ac_file in conftest.exe conftest conftest.*; do
-     * ) break;;
-   esac
- done
--else
--  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
--$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-+else case e in #(
-+  e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
- as_fn_error $? "cannot compute suffix of executables: cannot compile and link
--See \`config.log' for more details" "$LINENO" 5; }
-+See 'config.log' for more details" "$LINENO" 5; } ;;
-+esac
- fi
- rm -f conftest conftest$ac_cv_exeext
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
--$as_echo "$ac_cv_exeext" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
-+printf "%s\n" "$ac_cv_exeext" >&6; }
- 
- rm -f conftest.$ac_ext
- EXEEXT=$ac_cv_exeext
-@@ -29056,9 +31021,11 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- #include <stdio.h>
- int
--main ()
-+main (void)
- {
- FILE *f = fopen ("conftest.out", "w");
-+ if (!f)
-+  return 1;
-  return ferror (f) || fclose (f) != 0;
- 
-   ;
-@@ -29068,8 +31035,8 @@ _ACEOF
- ac_clean_files="$ac_clean_files conftest.out"
- # Check that the compiler produces executables we can run.  If not, either
- # the compiler is broken, or we cross compile.
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
--$as_echo_n "checking whether we are cross compiling... " >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
-+printf %s "checking whether we are cross compiling... " >&6; }
- if test "$cross_compiling" != yes; then
-   { { ac_try="$ac_link"
- case "(($ac_try" in
-@@ -29077,10 +31044,10 @@ case "(($ac_try" in
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_link") 2>&5
-   ac_status=$?
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; }
-   if { ac_try='./conftest$ac_cv_exeext'
-   { { case "(($ac_try" in
-@@ -29088,39 +31055,41 @@ $as_echo "$ac_try_echo"; } >&5
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_try") 2>&5
-   ac_status=$?
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; }; }; then
-     cross_compiling=no
-   else
-     if test "$cross_compiling" = maybe; then
- 	cross_compiling=yes
-     else
--	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
--$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
--as_fn_error $? "cannot run C compiled programs.
--If you meant to cross compile, use \`--host'.
--See \`config.log' for more details" "$LINENO" 5; }
-+	{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
-+as_fn_error 77 "cannot run C compiled programs.
-+If you meant to cross compile, use '--host'.
-+See 'config.log' for more details" "$LINENO" 5; }
-     fi
-   fi
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
--$as_echo "$cross_compiling" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
-+printf "%s\n" "$cross_compiling" >&6; }
- 
--rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
-+rm -f conftest.$ac_ext conftest$ac_cv_exeext \
-+  conftest.o conftest.obj conftest.out
- ac_clean_files=$ac_clean_files_save
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
--$as_echo_n "checking for suffix of object files... " >&6; }
--if ${ac_cv_objext+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
-+printf %s "checking for suffix of object files... " >&6; }
-+if test ${ac_cv_objext+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-@@ -29134,11 +31103,12 @@ case "(($ac_try" in
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_compile") 2>&5
-   ac_status=$?
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
--  test $ac_status = 0; }; then :
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  test $ac_status = 0; }
-+then :
-   for ac_file in conftest.o conftest.obj conftest.*; do
-   test -f "$ac_file" || continue;
-   case $ac_file in
-@@ -29147,31 +31117,34 @@ $as_echo "$ac_try_echo"; } >&5
-        break;;
-   esac
- done
--else
--  $as_echo "$as_me: failed program was:" >&5
-+else case e in #(
-+  e) printf "%s\n" "$as_me: failed program was:" >&5
- sed 's/^/| /' conftest.$ac_ext >&5
- 
--{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
--$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-+{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
- as_fn_error $? "cannot compute suffix of object files: cannot compile
--See \`config.log' for more details" "$LINENO" 5; }
-+See 'config.log' for more details" "$LINENO" 5; } ;;
-+esac
- fi
--rm -f conftest.$ac_cv_objext conftest.$ac_ext
-+rm -f conftest.$ac_cv_objext conftest.$ac_ext ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
--$as_echo "$ac_cv_objext" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
-+printf "%s\n" "$ac_cv_objext" >&6; }
- OBJEXT=$ac_cv_objext
- ac_objext=$OBJEXT
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
--$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
--if ${ac_cv_c_compiler_gnu+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C" >&5
-+printf %s "checking whether the compiler supports GNU C... " >&6; }
-+if test ${ac_cv_c_compiler_gnu+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- #ifndef __GNUC__
-        choke me
-@@ -29181,30 +31154,36 @@ main ()
-   return 0;
- }
- _ACEOF
--if ac_fn_c_try_compile "$LINENO"; then :
-+if ac_fn_c_try_compile "$LINENO"
-+then :
-   ac_compiler_gnu=yes
--else
--  ac_compiler_gnu=no
-+else case e in #(
-+  e) ac_compiler_gnu=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
- ac_cv_c_compiler_gnu=$ac_compiler_gnu
--
-+ ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
--$as_echo "$ac_cv_c_compiler_gnu" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
-+printf "%s\n" "$ac_cv_c_compiler_gnu" >&6; }
-+ac_compiler_gnu=$ac_cv_c_compiler_gnu
-+
- if test $ac_compiler_gnu = yes; then
-   GCC=yes
- else
-   GCC=
- fi
--ac_test_CFLAGS=${CFLAGS+set}
-+ac_test_CFLAGS=${CFLAGS+y}
- ac_save_CFLAGS=$CFLAGS
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
--$as_echo_n "checking whether $CC accepts -g... " >&6; }
--if ${ac_cv_prog_cc_g+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_save_c_werror_flag=$ac_c_werror_flag
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
-+printf %s "checking whether $CC accepts -g... " >&6; }
-+if test ${ac_cv_prog_cc_g+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_save_c_werror_flag=$ac_c_werror_flag
-    ac_c_werror_flag=yes
-    ac_cv_prog_cc_g=no
-    CFLAGS="-g"
-@@ -29212,57 +31191,63 @@ else
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_c_try_compile "$LINENO"; then :
-+if ac_fn_c_try_compile "$LINENO"
-+then :
-   ac_cv_prog_cc_g=yes
--else
--  CFLAGS=""
-+else case e in #(
-+  e) CFLAGS=""
-       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_c_try_compile "$LINENO"; then :
-+if ac_fn_c_try_compile "$LINENO"
-+then :
- 
--else
--  ac_c_werror_flag=$ac_save_c_werror_flag
-+else case e in #(
-+  e) ac_c_werror_flag=$ac_save_c_werror_flag
- 	 CFLAGS="-g"
- 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_c_try_compile "$LINENO"; then :
-+if ac_fn_c_try_compile "$LINENO"
-+then :
-   ac_cv_prog_cc_g=yes
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
--   ac_c_werror_flag=$ac_save_c_werror_flag
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-+   ac_c_werror_flag=$ac_save_c_werror_flag ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
--$as_echo "$ac_cv_prog_cc_g" >&6; }
--if test "$ac_test_CFLAGS" = set; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
-+printf "%s\n" "$ac_cv_prog_cc_g" >&6; }
-+if test $ac_test_CFLAGS; then
-   CFLAGS=$ac_save_CFLAGS
- elif test $ac_cv_prog_cc_g = yes; then
-   if test "$GCC" = yes; then
-@@ -29277,94 +31262,153 @@ else
-     CFLAGS=
-   fi
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
--$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
--if ${ac_cv_prog_cc_c89+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_cv_prog_cc_c89=no
-+ac_prog_cc_stdc=no
-+if test x$ac_prog_cc_stdc = xno
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C11 features" >&5
-+printf %s "checking for $CC option to enable C11 features... " >&6; }
-+if test ${ac_cv_prog_cc_c11+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_cv_prog_cc_c11=no
- ac_save_CC=$CC
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
--#include <stdarg.h>
--#include <stdio.h>
--struct stat;
--/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
--struct buf { int x; };
--FILE * (*rcsopen) (struct buf *, struct stat *, int);
--static char *e (p, i)
--     char **p;
--     int i;
--{
--  return p[i];
--}
--static char *f (char * (*g) (char **, int), char **p, ...)
--{
--  char *s;
--  va_list v;
--  va_start (v,p);
--  s = g (p, va_arg (v,int));
--  va_end (v);
--  return s;
--}
--
--/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
--   function prototypes and stuff, but not '\xHH' hex character constants.
--   These don't provoke an error unfortunately, instead are silently treated
--   as 'x'.  The following induces an error, until -std is added to get
--   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
--   array size at least.  It's necessary to write '\x00'==0 to get something
--   that's true only with -std.  */
--int osf4_cc_array ['\x00' == 0 ? 1 : -1];
-+$ac_c_conftest_c11_program
-+_ACEOF
-+for ac_arg in '' -std=gnu11
-+do
-+  CC="$ac_save_CC $ac_arg"
-+  if ac_fn_c_try_compile "$LINENO"
-+then :
-+  ac_cv_prog_cc_c11=$ac_arg
-+fi
-+rm -f core conftest.err conftest.$ac_objext conftest.beam
-+  test "x$ac_cv_prog_cc_c11" != "xno" && break
-+done
-+rm -f conftest.$ac_ext
-+CC=$ac_save_CC ;;
-+esac
-+fi
- 
--/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
--   inside strings and character constants.  */
--#define FOO(x) 'x'
--int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
-+if test "x$ac_cv_prog_cc_c11" = xno
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-+printf "%s\n" "unsupported" >&6; }
-+else case e in #(
-+  e) if test "x$ac_cv_prog_cc_c11" = x
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-+printf "%s\n" "none needed" >&6; }
-+else case e in #(
-+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c11" >&5
-+printf "%s\n" "$ac_cv_prog_cc_c11" >&6; }
-+     CC="$CC $ac_cv_prog_cc_c11" ;;
-+esac
-+fi
-+  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c11
-+  ac_prog_cc_stdc=c11 ;;
-+esac
-+fi
-+fi
-+if test x$ac_prog_cc_stdc = xno
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C99 features" >&5
-+printf %s "checking for $CC option to enable C99 features... " >&6; }
-+if test ${ac_cv_prog_cc_c99+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_cv_prog_cc_c99=no
-+ac_save_CC=$CC
-+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+/* end confdefs.h.  */
-+$ac_c_conftest_c99_program
-+_ACEOF
-+for ac_arg in '' -std=gnu99 -std=c99 -c99 -qlanglvl=extc1x -qlanglvl=extc99 -AC99 -D_STDC_C99=
-+do
-+  CC="$ac_save_CC $ac_arg"
-+  if ac_fn_c_try_compile "$LINENO"
-+then :
-+  ac_cv_prog_cc_c99=$ac_arg
-+fi
-+rm -f core conftest.err conftest.$ac_objext conftest.beam
-+  test "x$ac_cv_prog_cc_c99" != "xno" && break
-+done
-+rm -f conftest.$ac_ext
-+CC=$ac_save_CC ;;
-+esac
-+fi
- 
--int test (int i, double x);
--struct s1 {int (*f) (int a);};
--struct s2 {int (*f) (double a);};
--int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
--int argc;
--char **argv;
--int
--main ()
--{
--return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
--  ;
--  return 0;
--}
-+if test "x$ac_cv_prog_cc_c99" = xno
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-+printf "%s\n" "unsupported" >&6; }
-+else case e in #(
-+  e) if test "x$ac_cv_prog_cc_c99" = x
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-+printf "%s\n" "none needed" >&6; }
-+else case e in #(
-+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
-+printf "%s\n" "$ac_cv_prog_cc_c99" >&6; }
-+     CC="$CC $ac_cv_prog_cc_c99" ;;
-+esac
-+fi
-+  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
-+  ac_prog_cc_stdc=c99 ;;
-+esac
-+fi
-+fi
-+if test x$ac_prog_cc_stdc = xno
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CC option to enable C89 features" >&5
-+printf %s "checking for $CC option to enable C89 features... " >&6; }
-+if test ${ac_cv_prog_cc_c89+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_cv_prog_cc_c89=no
-+ac_save_CC=$CC
-+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+/* end confdefs.h.  */
-+$ac_c_conftest_c89_program
- _ACEOF
--for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
--	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
-+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
- do
-   CC="$ac_save_CC $ac_arg"
--  if ac_fn_c_try_compile "$LINENO"; then :
-+  if ac_fn_c_try_compile "$LINENO"
-+then :
-   ac_cv_prog_cc_c89=$ac_arg
- fi
--rm -f core conftest.err conftest.$ac_objext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam
-   test "x$ac_cv_prog_cc_c89" != "xno" && break
- done
- rm -f conftest.$ac_ext
--CC=$ac_save_CC
-+CC=$ac_save_CC ;;
-+esac
-+fi
- 
-+if test "x$ac_cv_prog_cc_c89" = xno
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-+printf "%s\n" "unsupported" >&6; }
-+else case e in #(
-+  e) if test "x$ac_cv_prog_cc_c89" = x
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-+printf "%s\n" "none needed" >&6; }
-+else case e in #(
-+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
-+printf "%s\n" "$ac_cv_prog_cc_c89" >&6; }
-+     CC="$CC $ac_cv_prog_cc_c89" ;;
-+esac
- fi
--# AC_CACHE_VAL
--case "x$ac_cv_prog_cc_c89" in
--  x)
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
--$as_echo "none needed" >&6; } ;;
--  xno)
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
--$as_echo "unsupported" >&6; } ;;
--  *)
--    CC="$CC $ac_cv_prog_cc_c89"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
--$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
-+  ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
-+  ac_prog_cc_stdc=c89 ;;
- esac
--if test "x$ac_cv_prog_cc_c89" != xno; then :
--
-+fi
- fi
- 
- ac_ext=cpp
-@@ -29380,8 +31424,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   if test "x$CXX" != x; then
-     # User has supplied compiler name already, always let that override.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied compiler CXX=$CXX" >&5
--$as_echo "$as_me: Will use user supplied compiler CXX=$CXX" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied compiler CXX=$CXX" >&5
-+printf "%s\n" "$as_me: Will use user supplied compiler CXX=$CXX" >&6;}
-     if test "x`basename $CXX`" = "x$CXX"; then
-       # A command without a complete path is provided, search $PATH.
- 
-@@ -29389,12 +31433,13 @@ $as_echo "$as_me: Will use user supplied compiler CXX=$CXX" >&6;}
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_POTENTIAL_CXX+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $POTENTIAL_CXX in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_POTENTIAL_CXX+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $POTENTIAL_CXX in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_POTENTIAL_CXX="$POTENTIAL_CXX" # Let the user override the test with a path.
-   ;;
-@@ -29403,11 +31448,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_POTENTIAL_CXX="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_POTENTIAL_CXX="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -29415,15 +31464,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- POTENTIAL_CXX=$ac_cv_path_POTENTIAL_CXX
- if test -n "$POTENTIAL_CXX"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CXX" >&5
--$as_echo "$POTENTIAL_CXX" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CXX" >&5
-+printf "%s\n" "$POTENTIAL_CXX" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -29463,12 +31513,13 @@ done
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_TOOLCHAIN_PATH_CXX+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $TOOLCHAIN_PATH_CXX in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_TOOLCHAIN_PATH_CXX+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $TOOLCHAIN_PATH_CXX in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_TOOLCHAIN_PATH_CXX="$TOOLCHAIN_PATH_CXX" # Let the user override the test with a path.
-   ;;
-@@ -29477,11 +31528,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_TOOLCHAIN_PATH_CXX="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_TOOLCHAIN_PATH_CXX="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -29489,15 +31544,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- TOOLCHAIN_PATH_CXX=$ac_cv_path_TOOLCHAIN_PATH_CXX
- if test -n "$TOOLCHAIN_PATH_CXX"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH_CXX" >&5
--$as_echo "$TOOLCHAIN_PATH_CXX" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $TOOLCHAIN_PATH_CXX" >&5
-+printf "%s\n" "$TOOLCHAIN_PATH_CXX" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -29515,12 +31571,13 @@ done
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_POTENTIAL_CXX+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $POTENTIAL_CXX in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_POTENTIAL_CXX+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $POTENTIAL_CXX in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_POTENTIAL_CXX="$POTENTIAL_CXX" # Let the user override the test with a path.
-   ;;
-@@ -29529,11 +31586,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_POTENTIAL_CXX="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_POTENTIAL_CXX="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -29541,15 +31602,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- POTENTIAL_CXX=$ac_cv_path_POTENTIAL_CXX
- if test -n "$POTENTIAL_CXX"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CXX" >&5
--$as_echo "$POTENTIAL_CXX" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $POTENTIAL_CXX" >&5
-+printf "%s\n" "$POTENTIAL_CXX" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -29636,12 +31698,12 @@ done
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
-     fi
-@@ -29663,10 +31725,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of CXX, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CXX, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
-     fi
-   else
-@@ -29776,12 +31838,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
-     fi
-@@ -29853,12 +31915,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXX, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of CXX, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of CXX" "$LINENO" 5
-     fi
-@@ -29873,14 +31935,14 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     CXX="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CXX to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting CXX to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CXX to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting CXX to \"$new_complete\"" >&6;}
-   fi
- 
-   TEST_COMPILER="$CXX"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking resolved symbolic links for CXX" >&5
--$as_echo_n "checking resolved symbolic links for CXX... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking resolved symbolic links for CXX" >&5
-+printf %s "checking resolved symbolic links for CXX... " >&6; }
-   SYMLINK_ORIGINAL="$TEST_COMPILER"
- 
-   if test "x$OPENJDK_BUILD_OS" != xwindows; then
-@@ -29931,17 +31993,17 @@ $as_echo_n "checking resolved symbolic links for CXX... " >&6; }
-   fi
- 
-   if test "x$TEST_COMPILER" = "x$SYMLINK_ORIGINAL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no symlink" >&5
--$as_echo "no symlink" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no symlink" >&5
-+printf "%s\n" "no symlink" >&6; }
-   else
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $SYMLINK_ORIGINAL" >&5
--$as_echo "$SYMLINK_ORIGINAL" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if CXX is disguised ccache" >&5
--$as_echo_n "checking if CXX is disguised ccache... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $SYMLINK_ORIGINAL" >&5
-+printf "%s\n" "$SYMLINK_ORIGINAL" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if CXX is disguised ccache" >&5
-+printf %s "checking if CXX is disguised ccache... " >&6; }
-     COMPILER_BASENAME=`$BASENAME "$SYMLINK_ORIGINAL"`
-     if test "x$COMPILER_BASENAME" = "xccache"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes, trying to find proper $COMPILER_NAME compiler" >&5
--$as_echo "yes, trying to find proper $COMPILER_NAME compiler" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes, trying to find proper $COMPILER_NAME compiler" >&5
-+printf "%s\n" "yes, trying to find proper $COMPILER_NAME compiler" >&6; }
-       # We /usr/lib/ccache in the path, so cc is a symlink to /usr/bin/ccache.
-       # We want to control ccache invocation ourselves, so ignore this cc and try
-       # searching again.
-@@ -29956,38 +32018,44 @@ $as_echo "yes, trying to find proper $COMPILER_NAME compiler" >&6; }
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_PROPER_COMPILER_CXX+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$PROPER_COMPILER_CXX"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_PROPER_COMPILER_CXX+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$PROPER_COMPILER_CXX"; then
-   ac_cv_prog_PROPER_COMPILER_CXX="$PROPER_COMPILER_CXX" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_PROPER_COMPILER_CXX="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- PROPER_COMPILER_CXX=$ac_cv_prog_PROPER_COMPILER_CXX
- if test -n "$PROPER_COMPILER_CXX"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CXX" >&5
--$as_echo "$PROPER_COMPILER_CXX" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CXX" >&5
-+printf "%s\n" "$PROPER_COMPILER_CXX" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -30000,38 +32068,44 @@ if test -z "$PROPER_COMPILER_CXX"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_PROPER_COMPILER_CXX+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_PROPER_COMPILER_CXX"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_PROPER_COMPILER_CXX+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_PROPER_COMPILER_CXX"; then
-   ac_cv_prog_ac_ct_PROPER_COMPILER_CXX="$ac_ct_PROPER_COMPILER_CXX" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_PROPER_COMPILER_CXX="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_PROPER_COMPILER_CXX=$ac_cv_prog_ac_ct_PROPER_COMPILER_CXX
- if test -n "$ac_ct_PROPER_COMPILER_CXX"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_PROPER_COMPILER_CXX" >&5
--$as_echo "$ac_ct_PROPER_COMPILER_CXX" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_PROPER_COMPILER_CXX" >&5
-+printf "%s\n" "$ac_ct_PROPER_COMPILER_CXX" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -30043,8 +32117,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     PROPER_COMPILER_CXX=$ac_ct_PROPER_COMPILER_CXX
-@@ -30092,12 +32166,12 @@ fi
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CXX" "$LINENO" 5
-     fi
-@@ -30119,10 +32193,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CXX" "$LINENO" 5
-     fi
-   else
-@@ -30232,12 +32306,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CXX" "$LINENO" 5
-     fi
-@@ -30309,12 +32383,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of PROPER_COMPILER_CXX, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of PROPER_COMPILER_CXX" "$LINENO" 5
-     fi
-@@ -30329,14 +32403,14 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     PROPER_COMPILER_CXX="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting PROPER_COMPILER_CXX to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting PROPER_COMPILER_CXX to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting PROPER_COMPILER_CXX to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting PROPER_COMPILER_CXX to \"$new_complete\"" >&6;}
-   fi
- 
-       PATH="$RETRY_COMPILER_SAVED_PATH"
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for resolved symbolic links for CXX" >&5
--$as_echo_n "checking for resolved symbolic links for CXX... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for resolved symbolic links for CXX" >&5
-+printf %s "checking for resolved symbolic links for CXX... " >&6; }
- 
-   if test "x$OPENJDK_BUILD_OS" != xwindows; then
-     # Follow a chain of symbolic links. Use readlink
-@@ -30385,12 +32459,12 @@ $as_echo_n "checking for resolved symbolic links for CXX... " >&6; }
-     fi
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CXX" >&5
--$as_echo "$PROPER_COMPILER_CXX" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $PROPER_COMPILER_CXX" >&5
-+printf "%s\n" "$PROPER_COMPILER_CXX" >&6; }
-       CXX="$PROPER_COMPILER_CXX"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, keeping CXX" >&5
--$as_echo "no, keeping CXX" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, keeping CXX" >&5
-+printf "%s\n" "no, keeping CXX" >&6; }
-     fi
-   fi
- 
-@@ -30406,12 +32480,12 @@ $as_echo "no, keeping CXX" >&6; }
-     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "^.*: Sun $COMPILER_NAME" > /dev/null
-     if test $? -ne 0; then
-       ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
--$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
--$as_echo "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
--$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
-+printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&5
-+printf "%s\n" "$as_me: The result from running with -V was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
-+printf "%s\n" "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
-       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
-     fi
-     # Remove usage instructions (if present), and
-@@ -30429,12 +32503,12 @@ $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUT
-     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "IBM XL C" > /dev/null
-     if test $? -ne 0; then
-       ALT_VERSION_OUTPUT=`$COMPILER --version 2>&1`
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
--$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
--$as_echo "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
--$as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
-+printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&5
-+printf "%s\n" "$as_me: The result from running with -qversion was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&5
-+printf "%s\n" "$as_me: The result from running with --version was: \"$ALT_VERSION_OUTPUT\"" >&6;}
-       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
-     fi
-     # Collapse compiler output into a single line
-@@ -30449,10 +32523,10 @@ $as_echo "$as_me: The result from running with --version was: \"$ALT_VERSION_OUT
-     # Check that this is likely to be Microsoft CL.EXE.
-     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Microsoft.*Compiler" > /dev/null
-     if test $? -ne 0; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
--$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
--$as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
-+printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&5
-+printf "%s\n" "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
-       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
-     fi
-     # Collapse compiler output into a single line
-@@ -30469,10 +32543,10 @@ $as_echo "$as_me: The result from running it was: \"$COMPILER_VERSION_OUTPUT\""
-     # Check that this is likely to be GCC.
-     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "Free Software Foundation" > /dev/null
-     if test $? -ne 0; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
--$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
--$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
-+printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION\"" >&5
-+printf "%s\n" "$as_me: The result from running with --version was: \"$COMPILER_VERSION\"" >&6;}
-       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
-     fi
-     # Remove Copyright and legalese from version string, and
-@@ -30493,10 +32567,10 @@ $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSIO
-     # Check that this is likely to be clang
-     $ECHO "$COMPILER_VERSION_OUTPUT" | $GREP "clang" > /dev/null
-     if test $? -ne 0; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
--$as_echo "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
--$as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&5
-+printf "%s\n" "$as_me: The $COMPILER_NAME compiler (located as $COMPILER) does not seem to be the required $TOOLCHAIN_TYPE compiler." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&5
-+printf "%s\n" "$as_me: The result from running with --version was: \"$COMPILER_VERSION_OUTPUT\"" >&6;}
-       as_fn_error $? "A $TOOLCHAIN_TYPE compiler is required. Try setting --with-tools-dir." "$LINENO" 5
-     fi
-     # Collapse compiler output into a single line
-@@ -30512,8 +32586,8 @@ $as_echo "$as_me: The result from running with --version was: \"$COMPILER_VERSIO
-   # This sets CC_VERSION_STRING or CXX_VERSION_STRING. (This comment is a grep marker)
-   CXX_VERSION_STRING="$COMPILER_VERSION_STRING"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
--$as_echo "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&5
-+printf "%s\n" "$as_me: Using $TOOLCHAIN_TYPE $COMPILER_NAME compiler version $COMPILER_VERSION_NUMBER [$COMPILER_VERSION_STRING]" >&6;}
- 
- 
-   # Now that we have resolved CXX ourself, let autoconf have its go at it
-@@ -30531,38 +32605,44 @@ if test -z "$CXX"; then
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_CXX+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$CXX"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_CXX+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$CXX"; then
-   ac_cv_prog_CXX="$CXX" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- CXX=$ac_cv_prog_CXX
- if test -n "$CXX"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
--$as_echo "$CXX" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
-+printf "%s\n" "$CXX" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -30575,38 +32655,44 @@ if test -z "$CXX"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_CXX+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_CXX"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_CXX+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_CXX"; then
-   ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_CXX="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
- if test -n "$ac_ct_CXX"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
--$as_echo "$ac_ct_CXX" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
-+printf "%s\n" "$ac_ct_CXX" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -30618,8 +32704,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     CXX=$ac_ct_CXX
-@@ -30629,7 +32715,7 @@ fi
-   fi
- fi
- # Provide some information about the compiler.
--$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
-+printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
- set X $ac_compile
- ac_compiler=$2
- for ac_option in --version -v -V -qversion; do
-@@ -30639,7 +32725,7 @@ case "(($ac_try" in
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_compiler $ac_option >&5") 2>conftest.err
-   ac_status=$?
-   if test -s conftest.err; then
-@@ -30649,20 +32735,21 @@ $as_echo "$ac_try_echo"; } >&5
-     cat conftest.er1 >&5
-   fi
-   rm -f conftest.er1 conftest.err
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; }
- done
- 
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
--$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
--if ${ac_cv_cxx_compiler_gnu+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU C++" >&5
-+printf %s "checking whether the compiler supports GNU C++... " >&6; }
-+if test ${ac_cv_cxx_compiler_gnu+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- #ifndef __GNUC__
-        choke me
-@@ -30672,30 +32759,36 @@ main ()
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-   ac_compiler_gnu=yes
--else
--  ac_compiler_gnu=no
-+else case e in #(
-+  e) ac_compiler_gnu=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
- ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
--
-+ ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
--$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
-+printf "%s\n" "$ac_cv_cxx_compiler_gnu" >&6; }
-+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
-+
- if test $ac_compiler_gnu = yes; then
-   GXX=yes
- else
-   GXX=
- fi
--ac_test_CXXFLAGS=${CXXFLAGS+set}
-+ac_test_CXXFLAGS=${CXXFLAGS+y}
- ac_save_CXXFLAGS=$CXXFLAGS
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
--$as_echo_n "checking whether $CXX accepts -g... " >&6; }
--if ${ac_cv_prog_cxx_g+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
-+printf %s "checking whether $CXX accepts -g... " >&6; }
-+if test ${ac_cv_prog_cxx_g+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_save_cxx_werror_flag=$ac_cxx_werror_flag
-    ac_cxx_werror_flag=yes
-    ac_cv_prog_cxx_g=no
-    CXXFLAGS="-g"
-@@ -30703,57 +32796,63 @@ else
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-   ac_cv_prog_cxx_g=yes
--else
--  CXXFLAGS=""
-+else case e in #(
-+  e) CXXFLAGS=""
-       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
- 
--else
--  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
-+else case e in #(
-+  e) ac_cxx_werror_flag=$ac_save_cxx_werror_flag
- 	 CXXFLAGS="-g"
- 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-   ac_cv_prog_cxx_g=yes
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
--   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-+   ac_cxx_werror_flag=$ac_save_cxx_werror_flag ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
--$as_echo "$ac_cv_prog_cxx_g" >&6; }
--if test "$ac_test_CXXFLAGS" = set; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
-+printf "%s\n" "$ac_cv_prog_cxx_g" >&6; }
-+if test $ac_test_CXXFLAGS; then
-   CXXFLAGS=$ac_save_CXXFLAGS
- elif test $ac_cv_prog_cxx_g = yes; then
-   if test "$GXX" = yes; then
-@@ -30768,6 +32867,106 @@ else
-     CXXFLAGS=
-   fi
- fi
-+ac_prog_cxx_stdcxx=no
-+if test x$ac_prog_cxx_stdcxx = xno
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++11 features" >&5
-+printf %s "checking for $CXX option to enable C++11 features... " >&6; }
-+if test ${ac_cv_prog_cxx_cxx11+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_cv_prog_cxx_cxx11=no
-+ac_save_CXX=$CXX
-+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+/* end confdefs.h.  */
-+$ac_cxx_conftest_cxx11_program
-+_ACEOF
-+for ac_arg in '' -std=gnu++11 -std=gnu++0x -std=c++11 -std=c++0x -qlanglvl=extended0x -AA
-+do
-+  CXX="$ac_save_CXX $ac_arg"
-+  if ac_fn_cxx_try_compile "$LINENO"
-+then :
-+  ac_cv_prog_cxx_cxx11=$ac_arg
-+fi
-+rm -f core conftest.err conftest.$ac_objext conftest.beam
-+  test "x$ac_cv_prog_cxx_cxx11" != "xno" && break
-+done
-+rm -f conftest.$ac_ext
-+CXX=$ac_save_CXX ;;
-+esac
-+fi
-+
-+if test "x$ac_cv_prog_cxx_cxx11" = xno
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-+printf "%s\n" "unsupported" >&6; }
-+else case e in #(
-+  e) if test "x$ac_cv_prog_cxx_cxx11" = x
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-+printf "%s\n" "none needed" >&6; }
-+else case e in #(
-+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx11" >&5
-+printf "%s\n" "$ac_cv_prog_cxx_cxx11" >&6; }
-+     CXX="$CXX $ac_cv_prog_cxx_cxx11" ;;
-+esac
-+fi
-+  ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx11
-+  ac_prog_cxx_stdcxx=cxx11 ;;
-+esac
-+fi
-+fi
-+if test x$ac_prog_cxx_stdcxx = xno
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $CXX option to enable C++98 features" >&5
-+printf %s "checking for $CXX option to enable C++98 features... " >&6; }
-+if test ${ac_cv_prog_cxx_cxx98+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_cv_prog_cxx_cxx98=no
-+ac_save_CXX=$CXX
-+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+/* end confdefs.h.  */
-+$ac_cxx_conftest_cxx98_program
-+_ACEOF
-+for ac_arg in '' -std=gnu++98 -std=c++98 -qlanglvl=extended -AA
-+do
-+  CXX="$ac_save_CXX $ac_arg"
-+  if ac_fn_cxx_try_compile "$LINENO"
-+then :
-+  ac_cv_prog_cxx_cxx98=$ac_arg
-+fi
-+rm -f core conftest.err conftest.$ac_objext conftest.beam
-+  test "x$ac_cv_prog_cxx_cxx98" != "xno" && break
-+done
-+rm -f conftest.$ac_ext
-+CXX=$ac_save_CXX ;;
-+esac
-+fi
-+
-+if test "x$ac_cv_prog_cxx_cxx98" = xno
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
-+printf "%s\n" "unsupported" >&6; }
-+else case e in #(
-+  e) if test "x$ac_cv_prog_cxx_cxx98" = x
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
-+printf "%s\n" "none needed" >&6; }
-+else case e in #(
-+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_cxx98" >&5
-+printf "%s\n" "$ac_cv_prog_cxx_cxx98" >&6; }
-+     CXX="$CXX $ac_cv_prog_cxx_cxx98" ;;
-+esac
-+fi
-+  ac_cv_prog_cxx_stdcxx=$ac_cv_prog_cxx_cxx98
-+  ac_prog_cxx_stdcxx=cxx98 ;;
-+esac
-+fi
-+fi
-+
- ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -30781,21 +32980,21 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
- 
-   if test "x$CC_VERSION_NUMBER" != "x$CXX_VERSION_NUMBER"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler has different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&5
--$as_echo "$as_me: WARNING: C and C++ compiler has different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&2;}
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This typically indicates a broken setup, and is not supported" >&5
--$as_echo "$as_me: WARNING: This typically indicates a broken setup, and is not supported" >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: C and C++ compiler has different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&5
-+printf "%s\n" "$as_me: WARNING: C and C++ compiler has different version numbers, $CC_VERSION_NUMBER vs $CXX_VERSION_NUMBER." >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: This typically indicates a broken setup, and is not supported" >&5
-+printf "%s\n" "$as_me: WARNING: This typically indicates a broken setup, and is not supported" >&2;}
-   fi
- 
-   # We only check CC_VERSION_NUMBER since we assume CXX_VERSION_NUMBER is equal.
-   if  [[ "$CC_VERSION_NUMBER" =~ (.*\.){3} ]] ; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION. Comparisons might be wrong." >&5
--$as_echo "$as_me: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION. Comparisons might be wrong." >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION. Comparisons might be wrong." >&5
-+printf "%s\n" "$as_me: WARNING: C compiler version number has more than three parts (X.Y.Z): $CC_VERSION. Comparisons might be wrong." >&2;}
-   fi
- 
-   if  [[  "$CC_VERSION_NUMBER" =~ [0-9]{6} ]] ; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION. Comparisons might be wrong." >&5
--$as_echo "$as_me: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION. Comparisons might be wrong." >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION. Comparisons might be wrong." >&5
-+printf "%s\n" "$as_me: WARNING: C compiler version number has a part larger than 99999: $CC_VERSION. Comparisons might be wrong." >&2;}
-   fi
- 
-   COMPARABLE_ACTUAL_VERSION=`$AWK -F. '{ printf("%05d%05d%05d\n", $1, $2, $3) }' <<< "$CC_VERSION_NUMBER"`
-@@ -30809,42 +33008,39 @@ ac_cpp='$CPP $CPPFLAGS'
- ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
- ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
- ac_compiler_gnu=$ac_cv_c_compiler_gnu
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
--$as_echo_n "checking how to run the C preprocessor... " >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
-+printf %s "checking how to run the C preprocessor... " >&6; }
- # On Suns, sometimes $CPP names a directory.
- if test -n "$CPP" && test -d "$CPP"; then
-   CPP=
- fi
- if test -z "$CPP"; then
--  if ${ac_cv_prog_CPP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--      # Double quotes because CPP needs to be expanded
--    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
-+  if test ${ac_cv_prog_CPP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e)     # Double quotes because $CC needs to be expanded
-+    for CPP in "$CC -E" "$CC -E -traditional-cpp" cpp /lib/cpp
-     do
-       ac_preproc_ok=false
- for ac_c_preproc_warn_flag in '' yes
- do
-   # Use a header file that comes with gcc, so configuring glibc
-   # with a fresh cross-compiler works.
--  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
--  # <limits.h> exists even on freestanding compilers.
-   # On the NeXT, cc -E runs the code through the compiler's parser,
-   # not just through cpp. "Syntax error" is here to catch this case.
-   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
--#ifdef __STDC__
--# include <limits.h>
--#else
--# include <assert.h>
--#endif
-+#include <limits.h>
- 		     Syntax error
- _ACEOF
--if ac_fn_c_try_cpp "$LINENO"; then :
-+if ac_fn_c_try_cpp "$LINENO"
-+then :
- 
--else
--  # Broken: fails on valid input.
--continue
-+else case e in #(
-+  e) # Broken: fails on valid input.
-+continue ;;
-+esac
- fi
- rm -f conftest.err conftest.i conftest.$ac_ext
- 
-@@ -30854,56 +33050,56 @@ rm -f conftest.err conftest.i conftest.$ac_ext
- /* end confdefs.h.  */
- #include <ac_nonexistent.h>
- _ACEOF
--if ac_fn_c_try_cpp "$LINENO"; then :
-+if ac_fn_c_try_cpp "$LINENO"
-+then :
-   # Broken: success on invalid input.
- continue
--else
--  # Passes both tests.
-+else case e in #(
-+  e) # Passes both tests.
- ac_preproc_ok=:
--break
-+break ;;
-+esac
- fi
- rm -f conftest.err conftest.i conftest.$ac_ext
- 
- done
--# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-+# Because of 'break', _AC_PREPROC_IFELSE's cleaning code was skipped.
- rm -f conftest.i conftest.err conftest.$ac_ext
--if $ac_preproc_ok; then :
-+if $ac_preproc_ok
-+then :
-   break
- fi
- 
-     done
-     ac_cv_prog_CPP=$CPP
--
-+   ;;
-+esac
- fi
-   CPP=$ac_cv_prog_CPP
- else
-   ac_cv_prog_CPP=$CPP
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
--$as_echo "$CPP" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
-+printf "%s\n" "$CPP" >&6; }
- ac_preproc_ok=false
- for ac_c_preproc_warn_flag in '' yes
- do
-   # Use a header file that comes with gcc, so configuring glibc
-   # with a fresh cross-compiler works.
--  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
--  # <limits.h> exists even on freestanding compilers.
-   # On the NeXT, cc -E runs the code through the compiler's parser,
-   # not just through cpp. "Syntax error" is here to catch this case.
-   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
--#ifdef __STDC__
--# include <limits.h>
--#else
--# include <assert.h>
--#endif
-+#include <limits.h>
- 		     Syntax error
- _ACEOF
--if ac_fn_c_try_cpp "$LINENO"; then :
-+if ac_fn_c_try_cpp "$LINENO"
-+then :
- 
--else
--  # Broken: fails on valid input.
--continue
-+else case e in #(
-+  e) # Broken: fails on valid input.
-+continue ;;
-+esac
- fi
- rm -f conftest.err conftest.i conftest.$ac_ext
- 
-@@ -30913,26 +33109,30 @@ rm -f conftest.err conftest.i conftest.$ac_ext
- /* end confdefs.h.  */
- #include <ac_nonexistent.h>
- _ACEOF
--if ac_fn_c_try_cpp "$LINENO"; then :
-+if ac_fn_c_try_cpp "$LINENO"
-+then :
-   # Broken: success on invalid input.
- continue
--else
--  # Passes both tests.
-+else case e in #(
-+  e) # Passes both tests.
- ac_preproc_ok=:
--break
-+break ;;
-+esac
- fi
- rm -f conftest.err conftest.i conftest.$ac_ext
- 
- done
--# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-+# Because of 'break', _AC_PREPROC_IFELSE's cleaning code was skipped.
- rm -f conftest.i conftest.err conftest.$ac_ext
--if $ac_preproc_ok; then :
-+if $ac_preproc_ok
-+then :
- 
--else
--  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
--$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-+else case e in #(
-+  e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
- as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
--See \`config.log' for more details" "$LINENO" 5; }
-+See 'config.log' for more details" "$LINENO" 5; } ;;
-+esac
- fi
- 
- ac_ext=cpp
-@@ -30982,12 +33182,12 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
-     fi
-@@ -31009,10 +33209,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of CPP, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CPP, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
-     fi
-   else
-@@ -31122,12 +33322,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
-     fi
-@@ -31199,12 +33399,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CPP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of CPP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of CPP" "$LINENO" 5
-     fi
-@@ -31219,8 +33419,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     CPP="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CPP to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting CPP to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CPP to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting CPP to \"$new_complete\"" >&6;}
-   fi
- 
-   ac_ext=cpp
-@@ -31228,38 +33428,35 @@ ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
- ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
- ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
--$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
-+printf %s "checking how to run the C++ preprocessor... " >&6; }
- if test -z "$CXXCPP"; then
--  if ${ac_cv_prog_CXXCPP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--      # Double quotes because CXXCPP needs to be expanded
--    for CXXCPP in "$CXX -E" "/lib/cpp"
-+  if test ${ac_cv_prog_CXXCPP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e)     # Double quotes because $CXX needs to be expanded
-+    for CXXCPP in "$CXX -E" cpp /lib/cpp
-     do
-       ac_preproc_ok=false
- for ac_cxx_preproc_warn_flag in '' yes
- do
-   # Use a header file that comes with gcc, so configuring glibc
-   # with a fresh cross-compiler works.
--  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
--  # <limits.h> exists even on freestanding compilers.
-   # On the NeXT, cc -E runs the code through the compiler's parser,
-   # not just through cpp. "Syntax error" is here to catch this case.
-   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
--#ifdef __STDC__
--# include <limits.h>
--#else
--# include <assert.h>
--#endif
-+#include <limits.h>
- 		     Syntax error
- _ACEOF
--if ac_fn_cxx_try_cpp "$LINENO"; then :
-+if ac_fn_cxx_try_cpp "$LINENO"
-+then :
- 
--else
--  # Broken: fails on valid input.
--continue
-+else case e in #(
-+  e) # Broken: fails on valid input.
-+continue ;;
-+esac
- fi
- rm -f conftest.err conftest.i conftest.$ac_ext
- 
-@@ -31269,56 +33466,56 @@ rm -f conftest.err conftest.i conftest.$ac_ext
- /* end confdefs.h.  */
- #include <ac_nonexistent.h>
- _ACEOF
--if ac_fn_cxx_try_cpp "$LINENO"; then :
-+if ac_fn_cxx_try_cpp "$LINENO"
-+then :
-   # Broken: success on invalid input.
- continue
--else
--  # Passes both tests.
-+else case e in #(
-+  e) # Passes both tests.
- ac_preproc_ok=:
--break
-+break ;;
-+esac
- fi
- rm -f conftest.err conftest.i conftest.$ac_ext
- 
- done
--# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-+# Because of 'break', _AC_PREPROC_IFELSE's cleaning code was skipped.
- rm -f conftest.i conftest.err conftest.$ac_ext
--if $ac_preproc_ok; then :
-+if $ac_preproc_ok
-+then :
-   break
- fi
- 
-     done
-     ac_cv_prog_CXXCPP=$CXXCPP
--
-+   ;;
-+esac
- fi
-   CXXCPP=$ac_cv_prog_CXXCPP
- else
-   ac_cv_prog_CXXCPP=$CXXCPP
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
--$as_echo "$CXXCPP" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
-+printf "%s\n" "$CXXCPP" >&6; }
- ac_preproc_ok=false
- for ac_cxx_preproc_warn_flag in '' yes
- do
-   # Use a header file that comes with gcc, so configuring glibc
-   # with a fresh cross-compiler works.
--  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
--  # <limits.h> exists even on freestanding compilers.
-   # On the NeXT, cc -E runs the code through the compiler's parser,
-   # not just through cpp. "Syntax error" is here to catch this case.
-   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
--#ifdef __STDC__
--# include <limits.h>
--#else
--# include <assert.h>
--#endif
-+#include <limits.h>
- 		     Syntax error
- _ACEOF
--if ac_fn_cxx_try_cpp "$LINENO"; then :
-+if ac_fn_cxx_try_cpp "$LINENO"
-+then :
- 
--else
--  # Broken: fails on valid input.
--continue
-+else case e in #(
-+  e) # Broken: fails on valid input.
-+continue ;;
-+esac
- fi
- rm -f conftest.err conftest.i conftest.$ac_ext
- 
-@@ -31328,26 +33525,30 @@ rm -f conftest.err conftest.i conftest.$ac_ext
- /* end confdefs.h.  */
- #include <ac_nonexistent.h>
- _ACEOF
--if ac_fn_cxx_try_cpp "$LINENO"; then :
-+if ac_fn_cxx_try_cpp "$LINENO"
-+then :
-   # Broken: success on invalid input.
- continue
--else
--  # Passes both tests.
-+else case e in #(
-+  e) # Passes both tests.
- ac_preproc_ok=:
--break
-+break ;;
-+esac
- fi
- rm -f conftest.err conftest.i conftest.$ac_ext
- 
- done
--# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-+# Because of 'break', _AC_PREPROC_IFELSE's cleaning code was skipped.
- rm -f conftest.i conftest.err conftest.$ac_ext
--if $ac_preproc_ok; then :
-+if $ac_preproc_ok
-+then :
- 
--else
--  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
--$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-+else case e in #(
-+  e) { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
- as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
--See \`config.log' for more details" "$LINENO" 5; }
-+See 'config.log' for more details" "$LINENO" 5; } ;;
-+esac
- fi
- 
- ac_ext=cpp
-@@ -31397,12 +33598,12 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
-     fi
-@@ -31424,10 +33625,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of CXXCPP, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CXXCPP, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
-     fi
-   else
-@@ -31537,12 +33738,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
-     fi
-@@ -31614,12 +33815,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CXXCPP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of CXXCPP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of CXXCPP" "$LINENO" 5
-     fi
-@@ -31634,8 +33835,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     CXXCPP="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CXXCPP to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting CXXCPP to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CXXCPP to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting CXXCPP to \"$new_complete\"" >&6;}
-   fi
- 
- 
-@@ -31648,12 +33849,13 @@ $as_echo "$as_me: Rewriting CXXCPP to \"$new_complete\"" >&6;}
-     # a cygwin program for something completely different.
-     # Extract the first word of "link", so it can be a program name with args.
- set dummy link; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_LD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$LD"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_LD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$LD"; then
-   ac_cv_prog_LD="$LD" # Let the user override the test.
- else
-   ac_prog_rejected=no
-@@ -31661,15 +33863,19 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    if test "$as_dir/$ac_word$ac_exec_ext" = "$CYGWIN_LINK"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    if test "$as_dir$ac_word$ac_exec_ext" = "$CYGWIN_LINK"; then
-        ac_prog_rejected=yes
-        continue
-      fi
-     ac_cv_prog_LD="link"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -31685,18 +33891,19 @@ if test $ac_prog_rejected = yes; then
-     # However, it has the same basename, so the bogon will be chosen
-     # first if we set LD to just the basename; use the full file name.
-     shift
--    ac_cv_prog_LD="$as_dir/$ac_word${1+' '}$@"
-+    ac_cv_prog_LD="$as_dir$ac_word${1+' '}$@"
-   fi
- fi
--fi
-+fi ;;
-+esac
- fi
- LD=$ac_cv_prog_LD
- if test -n "$LD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
--$as_echo "$LD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
-+printf "%s\n" "$LD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -31741,12 +33948,12 @@ fi
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
-     fi
-@@ -31768,10 +33975,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of LD, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of LD, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
-     fi
-   else
-@@ -31881,12 +34088,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
-     fi
-@@ -31958,12 +34165,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LD, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of LD, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of LD" "$LINENO" 5
-     fi
-@@ -31978,21 +34185,21 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     LD="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting LD to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting LD to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting LD to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting LD to \"$new_complete\"" >&6;}
-   fi
- 
-     # Verify that we indeed succeeded with this trick.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the found link.exe is actually the Visual Studio linker" >&5
--$as_echo_n "checking if the found link.exe is actually the Visual Studio linker... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the found link.exe is actually the Visual Studio linker" >&5
-+printf %s "checking if the found link.exe is actually the Visual Studio linker... " >&6; }
-     "$LD" --version > /dev/null
-     if test $? -eq 0 ; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-       as_fn_error $? "This is the Cygwin link tool. Please check your PATH and rerun configure." "$LINENO" 5
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
-     fi
-     LDCXX="$LD"
-   else
-@@ -32020,12 +34227,13 @@ $as_echo "yes" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_AS+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $AS in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_AS+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $AS in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_AS="$AS" # Let the user override the test with a path.
-   ;;
-@@ -32034,11 +34242,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_AS="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -32046,15 +34258,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- AS=$ac_cv_path_AS
- if test -n "$AS"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
--$as_echo "$AS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
-+printf "%s\n" "$AS" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -32070,20 +34283,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xAS" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of AS from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in as
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_AS+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $AS in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_AS+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $AS in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_AS="$AS" # Let the user override the test with a path.
-   ;;
-@@ -32092,11 +34306,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_AS="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -32104,15 +34322,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- AS=$ac_cv_path_AS
- if test -n "$AS"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
--$as_echo "$AS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
-+printf "%s\n" "$AS" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -32132,16 +34351,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AS=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool AS=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AS=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool AS=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_AS+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $AS in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_AS+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $AS in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_AS="$AS" # Let the user override the test with a path.
-   ;;
-@@ -32150,11 +34370,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_AS="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_AS="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -32162,15 +34386,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- AS=$ac_cv_path_AS
- if test -n "$AS"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
--$as_echo "$AS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AS" >&5
-+printf "%s\n" "$AS" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -32179,17 +34404,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AS=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool AS=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AS" >&5
--$as_echo_n "checking for AS... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AS=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool AS=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for AS" >&5
-+printf %s "checking for AS... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool AS=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -32236,12 +34461,12 @@ $as_echo "$tool_specified" >&6; }
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
-     fi
-@@ -32263,10 +34488,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of AS, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of AS, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
-     fi
-   else
-@@ -32376,12 +34601,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
-     fi
-@@ -32453,12 +34678,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AS, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of AS, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of AS" "$LINENO" 5
-     fi
-@@ -32473,8 +34698,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     AS="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting AS to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting AS to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting AS to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting AS to \"$new_complete\"" >&6;}
-   fi
- 
-   else
-@@ -32490,38 +34715,44 @@ $as_echo "$as_me: Rewriting AS to \"$new_complete\"" >&6;}
-     # The corresponding ar tool is lib.exe (used to create static libraries)
-     # Extract the first word of "lib", so it can be a program name with args.
- set dummy lib; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_AR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$AR"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_AR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$AR"; then
-   ac_cv_prog_AR="$AR" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_AR="lib"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- AR=$ac_cv_prog_AR
- if test -n "$AR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
--$as_echo "$AR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
-+printf "%s\n" "$AR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -32538,38 +34769,44 @@ fi
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_AR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$AR"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_AR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$AR"; then
-   ac_cv_prog_AR="$AR" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- AR=$ac_cv_prog_AR
- if test -n "$AR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
--$as_echo "$AR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
-+printf "%s\n" "$AR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -32582,38 +34819,44 @@ if test -z "$AR"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_AR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_AR"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_AR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_AR"; then
-   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_AR="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_AR=$ac_cv_prog_ac_ct_AR
- if test -n "$ac_ct_AR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
--$as_echo "$ac_ct_AR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
-+printf "%s\n" "$ac_ct_AR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -32625,8 +34868,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     AR=$ac_ct_AR
-@@ -32642,8 +34885,8 @@ fi
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xAR" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of AR from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       if test -n "$ac_tool_prefix"; then
-@@ -32651,38 +34894,44 @@ $as_echo "$as_me: WARNING: Ignoring value of AR from the environment. Use comman
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_AR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$AR"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_AR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$AR"; then
-   ac_cv_prog_AR="$AR" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- AR=$ac_cv_prog_AR
- if test -n "$AR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
--$as_echo "$AR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
-+printf "%s\n" "$AR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -32695,38 +34944,44 @@ if test -z "$AR"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_AR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_AR"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_AR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_AR"; then
-   ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_AR="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_AR=$ac_cv_prog_ac_ct_AR
- if test -n "$ac_ct_AR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
--$as_echo "$ac_ct_AR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
-+printf "%s\n" "$ac_ct_AR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -32738,8 +34993,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     AR=$ac_ct_AR
-@@ -32759,16 +35014,17 @@ fi
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AR=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool AR=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool AR=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool AR=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_AR+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $AR in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_AR+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $AR in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_AR="$AR" # Let the user override the test with a path.
-   ;;
-@@ -32777,11 +35033,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_AR="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_AR="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -32789,15 +35049,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- AR=$ac_cv_path_AR
- if test -n "$AR"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
--$as_echo "$AR" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
-+printf "%s\n" "$AR" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -32806,17 +35067,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AR=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool AR=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for AR" >&5
--$as_echo_n "checking for AR... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool AR=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool AR=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for AR" >&5
-+printf %s "checking for AR... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool AR=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -32864,12 +35125,12 @@ $as_echo "$tool_specified" >&6; }
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
-     fi
-@@ -32891,10 +35152,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of AR, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of AR, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
-     fi
-   else
-@@ -33004,12 +35265,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
-     fi
-@@ -33081,12 +35342,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of AR, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of AR, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of AR" "$LINENO" 5
-     fi
-@@ -33101,8 +35362,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     AR="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting AR to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting AR to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting AR to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting AR to \"$new_complete\"" >&6;}
-   fi
- 
- 
-@@ -33114,42 +35375,48 @@ ac_compile='$OBJC -c $OBJCFLAGS $CPPFLAGS conftest.$ac_ext >&5'
- ac_link='$OBJC -o conftest$ac_exeext $OBJCFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
- ac_compiler_gnu=$ac_cv_objc_compiler_gnu
- if test -n "$ac_tool_prefix"; then
--  for ac_prog in gcc objcc objc cc CC
-+  for ac_prog in gcc objcc objc cc CC clang
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_OBJC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$OBJC"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_OBJC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$OBJC"; then
-   ac_cv_prog_OBJC="$OBJC" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_OBJC="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- OBJC=$ac_cv_prog_OBJC
- if test -n "$OBJC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJC" >&5
--$as_echo "$OBJC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJC" >&5
-+printf "%s\n" "$OBJC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -33158,42 +35425,48 @@ fi
- fi
- if test -z "$OBJC"; then
-   ac_ct_OBJC=$OBJC
--  for ac_prog in gcc objcc objc cc CC
-+  for ac_prog in gcc objcc objc cc CC clang
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_OBJC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_OBJC"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_OBJC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_OBJC"; then
-   ac_cv_prog_ac_ct_OBJC="$ac_ct_OBJC" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_OBJC="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_OBJC=$ac_cv_prog_ac_ct_OBJC
- if test -n "$ac_ct_OBJC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJC" >&5
--$as_echo "$ac_ct_OBJC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJC" >&5
-+printf "%s\n" "$ac_ct_OBJC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -33205,8 +35478,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     OBJC=$ac_ct_OBJC
-@@ -33214,7 +35487,7 @@ esac
- fi
- 
- # Provide some information about the compiler.
--$as_echo "$as_me:${as_lineno-$LINENO}: checking for Objective C compiler version" >&5
-+printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for Objective C compiler version" >&5
- set X $ac_compile
- ac_compiler=$2
- for ac_option in --version -v -V -qversion; do
-@@ -33224,7 +35497,7 @@ case "(($ac_try" in
-   *) ac_try_echo=$ac_try;;
- esac
- eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
--$as_echo "$ac_try_echo"; } >&5
-+printf "%s\n" "$ac_try_echo"; } >&5
-   (eval "$ac_compiler $ac_option >&5") 2>conftest.err
-   ac_status=$?
-   if test -s conftest.err; then
-@@ -33234,20 +35507,21 @@ $as_echo "$ac_try_echo"; } >&5
-     cat conftest.er1 >&5
-   fi
-   rm -f conftest.er1 conftest.err
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; }
- done
- 
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU Objective C compiler" >&5
--$as_echo_n "checking whether we are using the GNU Objective C compiler... " >&6; }
--if ${ac_cv_objc_compiler_gnu+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether the compiler supports GNU Objective C" >&5
-+printf %s "checking whether the compiler supports GNU Objective C... " >&6; }
-+if test ${ac_cv_objc_compiler_gnu+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- #ifndef __GNUC__
-        choke me
-@@ -33257,30 +35531,36 @@ main ()
-   return 0;
- }
- _ACEOF
--if ac_fn_objc_try_compile "$LINENO"; then :
-+if ac_fn_objc_try_compile "$LINENO"
-+then :
-   ac_compiler_gnu=yes
--else
--  ac_compiler_gnu=no
-+else case e in #(
-+  e) ac_compiler_gnu=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
- ac_cv_objc_compiler_gnu=$ac_compiler_gnu
--
-+ ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objc_compiler_gnu" >&5
--$as_echo "$ac_cv_objc_compiler_gnu" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objc_compiler_gnu" >&5
-+printf "%s\n" "$ac_cv_objc_compiler_gnu" >&6; }
-+ac_compiler_gnu=$ac_cv_objc_compiler_gnu
-+
- if test $ac_compiler_gnu = yes; then
-   GOBJC=yes
- else
-   GOBJC=
- fi
--ac_test_OBJCFLAGS=${OBJCFLAGS+set}
-+ac_test_OBJCFLAGS=${OBJCFLAGS+y}
- ac_save_OBJCFLAGS=$OBJCFLAGS
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $OBJC accepts -g" >&5
--$as_echo_n "checking whether $OBJC accepts -g... " >&6; }
--if ${ac_cv_prog_objc_g+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_save_objc_werror_flag=$ac_objc_werror_flag
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether $OBJC accepts -g" >&5
-+printf %s "checking whether $OBJC accepts -g... " >&6; }
-+if test ${ac_cv_prog_objc_g+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_save_objc_werror_flag=$ac_objc_werror_flag
-    ac_objc_werror_flag=yes
-    ac_cv_prog_objc_g=no
-    OBJCFLAGS="-g"
-@@ -33288,57 +35568,63 @@ else
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_objc_try_compile "$LINENO"; then :
-+if ac_fn_objc_try_compile "$LINENO"
-+then :
-   ac_cv_prog_objc_g=yes
--else
--  OBJCFLAGS=""
-+else case e in #(
-+  e) OBJCFLAGS=""
-       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_objc_try_compile "$LINENO"; then :
-+if ac_fn_objc_try_compile "$LINENO"
-+then :
- 
--else
--  ac_objc_werror_flag=$ac_save_objc_werror_flag
-+else case e in #(
-+  e) ac_objc_werror_flag=$ac_save_objc_werror_flag
- 	 OBJCFLAGS="-g"
- 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_objc_try_compile "$LINENO"; then :
-+if ac_fn_objc_try_compile "$LINENO"
-+then :
-   ac_cv_prog_objc_g=yes
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
--   ac_objc_werror_flag=$ac_save_objc_werror_flag
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-+   ac_objc_werror_flag=$ac_save_objc_werror_flag ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_objc_g" >&5
--$as_echo "$ac_cv_prog_objc_g" >&6; }
--if test "$ac_test_OBJCFLAGS" = set; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_objc_g" >&5
-+printf "%s\n" "$ac_cv_prog_objc_g" >&6; }
-+if test $ac_test_OBJCFLAGS; then
-   OBJCFLAGS=$ac_save_OBJCFLAGS
- elif test $ac_cv_prog_objc_g = yes; then
-   if test "$GOBJC" = yes; then
-@@ -33400,12 +35686,12 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of OBJC" "$LINENO" 5
-     fi
-@@ -33427,10 +35713,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of OBJC, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of OBJC, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of OBJC" "$LINENO" 5
-     fi
-   else
-@@ -33540,12 +35826,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of OBJC" "$LINENO" 5
-     fi
-@@ -33617,12 +35903,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of OBJC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of OBJC" "$LINENO" 5
-     fi
-@@ -33637,8 +35923,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     OBJC="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OBJC to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting OBJC to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting OBJC to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting OBJC to \"$new_complete\"" >&6;}
-   fi
- 
- 
-@@ -33652,12 +35938,13 @@ $as_echo "$as_me: Rewriting OBJC to \"$new_complete\"" >&6;}
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_LIPO+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $LIPO in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_LIPO+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $LIPO in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_LIPO="$LIPO" # Let the user override the test with a path.
-   ;;
-@@ -33666,11 +35953,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_LIPO="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_LIPO="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -33678,15 +35969,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- LIPO=$ac_cv_path_LIPO
- if test -n "$LIPO"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
--$as_echo "$LIPO" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
-+printf "%s\n" "$LIPO" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -33702,20 +35994,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xLIPO" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LIPO from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of LIPO from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of LIPO from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of LIPO from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in lipo
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_LIPO+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $LIPO in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_LIPO+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $LIPO in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_LIPO="$LIPO" # Let the user override the test with a path.
-   ;;
-@@ -33724,11 +36017,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_LIPO="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_LIPO="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -33736,15 +36033,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- LIPO=$ac_cv_path_LIPO
- if test -n "$LIPO"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
--$as_echo "$LIPO" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
-+printf "%s\n" "$LIPO" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -33764,16 +36062,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LIPO=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool LIPO=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool LIPO=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool LIPO=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_LIPO+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $LIPO in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_LIPO+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $LIPO in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_LIPO="$LIPO" # Let the user override the test with a path.
-   ;;
-@@ -33782,11 +36081,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_LIPO="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_LIPO="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -33794,15 +36097,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- LIPO=$ac_cv_path_LIPO
- if test -n "$LIPO"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
--$as_echo "$LIPO" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
-+printf "%s\n" "$LIPO" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -33811,17 +36115,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LIPO=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool LIPO=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIPO" >&5
--$as_echo_n "checking for LIPO... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool LIPO=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool LIPO=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for LIPO" >&5
-+printf %s "checking for LIPO... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool LIPO=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -33868,12 +36172,12 @@ $as_echo "$tool_specified" >&6; }
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
-     fi
-@@ -33895,10 +36199,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of LIPO, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of LIPO, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
-     fi
-   else
-@@ -34008,12 +36312,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
-     fi
-@@ -34085,12 +36389,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of LIPO, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of LIPO, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of LIPO" "$LINENO" 5
-     fi
-@@ -34105,8 +36409,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     LIPO="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting LIPO to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting LIPO to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting LIPO to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting LIPO to \"$new_complete\"" >&6;}
-   fi
- 
-   else
-@@ -34116,12 +36420,13 @@ $as_echo "$as_me: Rewriting LIPO to \"$new_complete\"" >&6;}
-   if test "x$TOOLCHAIN_TYPE" = xmicrosoft; then
-     # Extract the first word of "mt", so it can be a program name with args.
- set dummy mt; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_MT+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$MT"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_MT+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$MT"; then
-   ac_cv_prog_MT="$MT" # Let the user override the test.
- else
-   ac_prog_rejected=no
-@@ -34129,15 +36434,19 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/mt"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    if test "$as_dir$ac_word$ac_exec_ext" = "/usr/bin/mt"; then
-        ac_prog_rejected=yes
-        continue
-      fi
-     ac_cv_prog_MT="mt"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -34153,18 +36462,19 @@ if test $ac_prog_rejected = yes; then
-     # However, it has the same basename, so the bogon will be chosen
-     # first if we set MT to just the basename; use the full file name.
-     shift
--    ac_cv_prog_MT="$as_dir/$ac_word${1+' '}$@"
-+    ac_cv_prog_MT="$as_dir$ac_word${1+' '}$@"
-   fi
- fi
--fi
-+fi ;;
-+esac
- fi
- MT=$ac_cv_prog_MT
- if test -n "$MT"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MT" >&5
--$as_echo "$MT" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MT" >&5
-+printf "%s\n" "$MT" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -34209,12 +36519,12 @@ fi
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
-     fi
-@@ -34236,10 +36546,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of MT, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MT, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
-     fi
-   else
-@@ -34349,12 +36659,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
-     fi
-@@ -34426,12 +36736,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MT, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of MT, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of MT" "$LINENO" 5
-     fi
-@@ -34446,19 +36756,20 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     MT="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MT to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting MT to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MT to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting MT to \"$new_complete\"" >&6;}
-   fi
- 
-     # Setup the resource compiler (RC)
-     # Extract the first word of "rc", so it can be a program name with args.
- set dummy rc; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_RC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$RC"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_RC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$RC"; then
-   ac_cv_prog_RC="$RC" # Let the user override the test.
- else
-   ac_prog_rejected=no
-@@ -34466,15 +36777,19 @@ as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/bin/rc"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    if test "$as_dir$ac_word$ac_exec_ext" = "/usr/bin/rc"; then
-        ac_prog_rejected=yes
-        continue
-      fi
-     ac_cv_prog_RC="rc"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -34490,18 +36805,19 @@ if test $ac_prog_rejected = yes; then
-     # However, it has the same basename, so the bogon will be chosen
-     # first if we set RC to just the basename; use the full file name.
-     shift
--    ac_cv_prog_RC="$as_dir/$ac_word${1+' '}$@"
-+    ac_cv_prog_RC="$as_dir$ac_word${1+' '}$@"
-   fi
- fi
--fi
-+fi ;;
-+esac
- fi
- RC=$ac_cv_prog_RC
- if test -n "$RC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RC" >&5
--$as_echo "$RC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $RC" >&5
-+printf "%s\n" "$RC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -34546,12 +36862,12 @@ fi
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
-     fi
-@@ -34573,10 +36889,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of RC, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of RC, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
-     fi
-   else
-@@ -34686,12 +37002,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
-     fi
-@@ -34763,12 +37079,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of RC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of RC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of RC" "$LINENO" 5
-     fi
-@@ -34783,44 +37099,50 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     RC="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting RC to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting RC to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting RC to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting RC to \"$new_complete\"" >&6;}
-   fi
- 
-     # Extract the first word of "dumpbin", so it can be a program name with args.
- set dummy dumpbin; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_DUMPBIN+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$DUMPBIN"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_DUMPBIN+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$DUMPBIN"; then
-   ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_DUMPBIN="dumpbin"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- DUMPBIN=$ac_cv_prog_DUMPBIN
- if test -n "$DUMPBIN"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
--$as_echo "$DUMPBIN" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
-+printf "%s\n" "$DUMPBIN" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -34865,12 +37187,12 @@ fi
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
-     fi
-@@ -34892,10 +37214,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of DUMPBIN, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of DUMPBIN, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
-     fi
-   else
-@@ -35005,12 +37327,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
-     fi
-@@ -35082,12 +37404,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of DUMPBIN, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of DUMPBIN" "$LINENO" 5
-     fi
-@@ -35102,8 +37424,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     DUMPBIN="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting DUMPBIN to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting DUMPBIN to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting DUMPBIN to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting DUMPBIN to \"$new_complete\"" >&6;}
-   fi
- 
-     # We need to check for 'msbuild.exe' because at the place where we expect to
-@@ -35115,38 +37437,44 @@ $as_echo "$as_me: Rewriting DUMPBIN to \"$new_complete\"" >&6;}
-     # 'LIB_SETUP_FREETYPE' in "libraries.m4"
-     # Extract the first word of "msbuild.exe", so it can be a program name with args.
- set dummy msbuild.exe; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_MSBUILD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$MSBUILD"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_MSBUILD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$MSBUILD"; then
-   ac_cv_prog_MSBUILD="$MSBUILD" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_MSBUILD="msbuild.exe"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- MSBUILD=$ac_cv_prog_MSBUILD
- if test -n "$MSBUILD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSBUILD" >&5
--$as_echo "$MSBUILD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSBUILD" >&5
-+printf "%s\n" "$MSBUILD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -35164,12 +37492,13 @@ fi
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_STRIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $STRIP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_STRIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $STRIP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
-   ;;
-@@ -35178,11 +37507,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_STRIP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -35190,15 +37523,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- STRIP=$ac_cv_path_STRIP
- if test -n "$STRIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
--$as_echo "$STRIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
-+printf "%s\n" "$STRIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -35214,20 +37548,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xSTRIP" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in strip
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_STRIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $STRIP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_STRIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $STRIP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
-   ;;
-@@ -35236,11 +37571,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_STRIP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -35248,15 +37587,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- STRIP=$ac_cv_path_STRIP
- if test -n "$STRIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
--$as_echo "$STRIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
-+printf "%s\n" "$STRIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -35276,16 +37616,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_STRIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $STRIP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_STRIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $STRIP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
-   ;;
-@@ -35294,11 +37635,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_STRIP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -35306,15 +37651,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- STRIP=$ac_cv_path_STRIP
- if test -n "$STRIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
--$as_echo "$STRIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
-+printf "%s\n" "$STRIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -35323,17 +37669,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
--$as_echo_n "checking for STRIP... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
-+printf %s "checking for STRIP... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool STRIP=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -35380,12 +37726,12 @@ $as_echo "$tool_specified" >&6; }
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
-     fi
-@@ -35407,10 +37753,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of STRIP, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
-     fi
-   else
-@@ -35520,12 +37866,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
-     fi
-@@ -35597,12 +37943,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
-     fi
-@@ -35617,8 +37963,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     STRIP="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
-   fi
- 
- 
-@@ -35632,12 +37978,13 @@ $as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_NM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $NM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_NM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $NM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_NM="$NM" # Let the user override the test with a path.
-   ;;
-@@ -35646,11 +37993,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_NM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -35658,15 +38009,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- NM=$ac_cv_path_NM
- if test -n "$NM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
--$as_echo "$NM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
-+printf "%s\n" "$NM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -35682,20 +38034,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xNM" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in nm
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_NM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $NM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_NM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $NM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_NM="$NM" # Let the user override the test with a path.
-   ;;
-@@ -35704,11 +38057,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_NM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -35716,15 +38073,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- NM=$ac_cv_path_NM
- if test -n "$NM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
--$as_echo "$NM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
-+printf "%s\n" "$NM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -35744,16 +38102,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_NM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $NM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_NM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $NM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_NM="$NM" # Let the user override the test with a path.
-   ;;
-@@ -35762,11 +38121,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_NM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -35774,15 +38137,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- NM=$ac_cv_path_NM
- if test -n "$NM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
--$as_echo "$NM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
-+printf "%s\n" "$NM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -35791,17 +38155,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
--$as_echo_n "checking for NM... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
-+printf %s "checking for NM... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool NM=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -35848,12 +38212,12 @@ $as_echo "$tool_specified" >&6; }
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
-     fi
-@@ -35875,10 +38239,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of NM, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of NM, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
-     fi
-   else
-@@ -35988,12 +38352,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
-     fi
-@@ -36065,12 +38429,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
-     fi
-@@ -36085,8 +38449,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     NM="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
-   fi
- 
- 
-@@ -36100,12 +38464,13 @@ $as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_GNM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $GNM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_GNM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $GNM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
-   ;;
-@@ -36114,11 +38479,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_GNM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -36126,15 +38495,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- GNM=$ac_cv_path_GNM
- if test -n "$GNM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
--$as_echo "$GNM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
-+printf "%s\n" "$GNM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -36150,20 +38520,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xGNM" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of GNM from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in gnm
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_GNM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $GNM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_GNM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $GNM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
-   ;;
-@@ -36172,11 +38543,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_GNM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -36184,15 +38559,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- GNM=$ac_cv_path_GNM
- if test -n "$GNM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
--$as_echo "$GNM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
-+printf "%s\n" "$GNM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -36212,16 +38588,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GNM=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool GNM=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool GNM=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool GNM=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_GNM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $GNM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_GNM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $GNM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_GNM="$GNM" # Let the user override the test with a path.
-   ;;
-@@ -36230,11 +38607,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_GNM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_GNM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -36242,15 +38623,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- GNM=$ac_cv_path_GNM
- if test -n "$GNM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
--$as_echo "$GNM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $GNM" >&5
-+printf "%s\n" "$GNM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -36259,17 +38641,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GNM=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool GNM=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNM" >&5
--$as_echo_n "checking for GNM... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool GNM=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool GNM=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for GNM" >&5
-+printf %s "checking for GNM... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool GNM=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -36316,12 +38698,12 @@ $as_echo "$tool_specified" >&6; }
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
-     fi
-@@ -36343,10 +38725,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of GNM, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of GNM, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
-     fi
-   else
-@@ -36456,12 +38838,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
-     fi
-@@ -36533,12 +38915,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of GNM, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of GNM, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of GNM" "$LINENO" 5
-     fi
-@@ -36553,8 +38935,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     GNM="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting GNM to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting GNM to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting GNM to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting GNM to \"$new_complete\"" >&6;}
-   fi
- 
- 
-@@ -36569,12 +38951,13 @@ $as_echo "$as_me: Rewriting GNM to \"$new_complete\"" >&6;}
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_MCS+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $MCS in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_MCS+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $MCS in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_MCS="$MCS" # Let the user override the test with a path.
-   ;;
-@@ -36583,11 +38966,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_MCS="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_MCS="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -36595,15 +38982,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- MCS=$ac_cv_path_MCS
- if test -n "$MCS"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
--$as_echo "$MCS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
-+printf "%s\n" "$MCS" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -36619,20 +39007,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xMCS" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MCS from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of MCS from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of MCS from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of MCS from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in mcs
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_MCS+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $MCS in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_MCS+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $MCS in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_MCS="$MCS" # Let the user override the test with a path.
-   ;;
-@@ -36641,11 +39030,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_MCS="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_MCS="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -36653,15 +39046,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- MCS=$ac_cv_path_MCS
- if test -n "$MCS"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
--$as_echo "$MCS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
-+printf "%s\n" "$MCS" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -36681,16 +39075,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MCS=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool MCS=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool MCS=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool MCS=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_MCS+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $MCS in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_MCS+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $MCS in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_MCS="$MCS" # Let the user override the test with a path.
-   ;;
-@@ -36699,11 +39094,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_MCS="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_MCS="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -36711,15 +39110,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- MCS=$ac_cv_path_MCS
- if test -n "$MCS"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
--$as_echo "$MCS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MCS" >&5
-+printf "%s\n" "$MCS" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -36728,17 +39128,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MCS=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool MCS=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for MCS" >&5
--$as_echo_n "checking for MCS... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool MCS=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool MCS=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for MCS" >&5
-+printf %s "checking for MCS... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool MCS=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -36785,12 +39185,12 @@ $as_echo "$tool_specified" >&6; }
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of MCS" "$LINENO" 5
-     fi
-@@ -36812,10 +39212,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of MCS, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MCS, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of MCS" "$LINENO" 5
-     fi
-   else
-@@ -36925,12 +39325,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of MCS" "$LINENO" 5
-     fi
-@@ -37002,12 +39402,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MCS, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of MCS, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of MCS" "$LINENO" 5
-     fi
-@@ -37022,8 +39422,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     MCS="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MCS to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting MCS to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MCS to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting MCS to \"$new_complete\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_TARGET_OS" != xwindows; then
-@@ -37040,38 +39440,44 @@ $as_echo "$as_me: Rewriting MCS to \"$new_complete\"" >&6;}
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_STRIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$STRIP"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_STRIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$STRIP"; then
-   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_STRIP="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- STRIP=$ac_cv_prog_STRIP
- if test -n "$STRIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
--$as_echo "$STRIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
-+printf "%s\n" "$STRIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -37084,38 +39490,44 @@ if test -z "$STRIP"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_STRIP"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_STRIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_STRIP"; then
-   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_STRIP="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
- if test -n "$ac_ct_STRIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
--$as_echo "$ac_ct_STRIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
-+printf "%s\n" "$ac_ct_STRIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -37127,8 +39539,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     STRIP=$ac_ct_STRIP
-@@ -37144,8 +39556,8 @@ fi
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xSTRIP" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of STRIP from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       if test -n "$ac_tool_prefix"; then
-@@ -37153,38 +39565,44 @@ $as_echo "$as_me: WARNING: Ignoring value of STRIP from the environment. Use com
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_STRIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$STRIP"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_STRIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$STRIP"; then
-   ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_STRIP="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- STRIP=$ac_cv_prog_STRIP
- if test -n "$STRIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
--$as_echo "$STRIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
-+printf "%s\n" "$STRIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -37197,38 +39615,44 @@ if test -z "$STRIP"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_STRIP"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_STRIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_STRIP"; then
-   ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_STRIP="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
- if test -n "$ac_ct_STRIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
--$as_echo "$ac_ct_STRIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
-+printf "%s\n" "$ac_ct_STRIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -37240,8 +39664,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     STRIP=$ac_ct_STRIP
-@@ -37261,16 +39685,17 @@ fi
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool STRIP=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool STRIP=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_STRIP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $STRIP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_STRIP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $STRIP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_STRIP="$STRIP" # Let the user override the test with a path.
-   ;;
-@@ -37279,11 +39704,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_STRIP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_STRIP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -37291,15 +39720,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- STRIP=$ac_cv_path_STRIP
- if test -n "$STRIP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
--$as_echo "$STRIP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
-+printf "%s\n" "$STRIP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -37308,17 +39738,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
--$as_echo_n "checking for STRIP... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool STRIP=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool STRIP=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for STRIP" >&5
-+printf %s "checking for STRIP... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool STRIP=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -37365,12 +39795,12 @@ $as_echo "$tool_specified" >&6; }
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
-     fi
-@@ -37392,10 +39822,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of STRIP, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
-     fi
-   else
-@@ -37505,12 +39935,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
-     fi
-@@ -37582,12 +40012,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of STRIP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of STRIP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of STRIP" "$LINENO" 5
-     fi
-@@ -37602,18 +40032,19 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     STRIP="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting STRIP to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting STRIP to \"$new_complete\"" >&6;}
-   fi
- 
-     # Extract the first word of "otool", so it can be a program name with args.
- set dummy otool; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_OTOOL+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $OTOOL in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_OTOOL+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $OTOOL in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_OTOOL="$OTOOL" # Let the user override the test with a path.
-   ;;
-@@ -37622,11 +40053,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_OTOOL="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_OTOOL="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -37634,15 +40069,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- OTOOL=$ac_cv_path_OTOOL
- if test -n "$OTOOL"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
--$as_echo "$OTOOL" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
-+printf "%s\n" "$OTOOL" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -37661,38 +40097,44 @@ fi
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_NM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$NM"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_NM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$NM"; then
-   ac_cv_prog_NM="$NM" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- NM=$ac_cv_prog_NM
- if test -n "$NM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
--$as_echo "$NM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
-+printf "%s\n" "$NM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -37705,38 +40147,44 @@ if test -z "$NM"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_NM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_NM"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_NM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_NM"; then
-   ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_NM="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_NM=$ac_cv_prog_ac_ct_NM
- if test -n "$ac_ct_NM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
--$as_echo "$ac_ct_NM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
-+printf "%s\n" "$ac_ct_NM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -37748,8 +40196,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     NM=$ac_ct_NM
-@@ -37765,8 +40213,8 @@ fi
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xNM" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of NM from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       if test -n "$ac_tool_prefix"; then
-@@ -37774,38 +40222,44 @@ $as_echo "$as_me: WARNING: Ignoring value of NM from the environment. Use comman
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_NM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$NM"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_NM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$NM"; then
-   ac_cv_prog_NM="$NM" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_NM="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- NM=$ac_cv_prog_NM
- if test -n "$NM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
--$as_echo "$NM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
-+printf "%s\n" "$NM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -37818,38 +40272,44 @@ if test -z "$NM"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_NM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_NM"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_NM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_NM"; then
-   ac_cv_prog_ac_ct_NM="$ac_ct_NM" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_NM="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_NM=$ac_cv_prog_ac_ct_NM
- if test -n "$ac_ct_NM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
--$as_echo "$ac_ct_NM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NM" >&5
-+printf "%s\n" "$ac_ct_NM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -37861,8 +40321,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     NM=$ac_ct_NM
-@@ -37882,16 +40342,17 @@ fi
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool NM=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool NM=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_NM+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $NM in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_NM+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $NM in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_NM="$NM" # Let the user override the test with a path.
-   ;;
-@@ -37900,11 +40361,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_NM="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_NM="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -37912,15 +40377,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- NM=$ac_cv_path_NM
- if test -n "$NM"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
--$as_echo "$NM" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NM" >&5
-+printf "%s\n" "$NM" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -37929,17 +40395,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
--$as_echo_n "checking for NM... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool NM=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool NM=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for NM" >&5
-+printf %s "checking for NM... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool NM=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -37986,12 +40452,12 @@ $as_echo "$tool_specified" >&6; }
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
-     fi
-@@ -38013,10 +40479,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of NM, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of NM, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
-     fi
-   else
-@@ -38126,12 +40592,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
-     fi
-@@ -38203,12 +40669,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of NM, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of NM, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of NM" "$LINENO" 5
-     fi
-@@ -38223,8 +40689,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     NM="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting NM to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
-   fi
- 
-     GNM="$NM"
-@@ -38246,38 +40712,44 @@ $as_echo "$as_me: Rewriting NM to \"$new_complete\"" >&6;}
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_OBJCOPY+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$OBJCOPY"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_OBJCOPY+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$OBJCOPY"; then
-   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_OBJCOPY="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- OBJCOPY=$ac_cv_prog_OBJCOPY
- if test -n "$OBJCOPY"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
--$as_echo "$OBJCOPY" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
-+printf "%s\n" "$OBJCOPY" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -38290,38 +40762,44 @@ if test -z "$OBJCOPY"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_OBJCOPY+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_OBJCOPY"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_OBJCOPY+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_OBJCOPY"; then
-   ac_cv_prog_ac_ct_OBJCOPY="$ac_ct_OBJCOPY" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_OBJCOPY="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_OBJCOPY=$ac_cv_prog_ac_ct_OBJCOPY
- if test -n "$ac_ct_OBJCOPY"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJCOPY" >&5
--$as_echo "$ac_ct_OBJCOPY" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJCOPY" >&5
-+printf "%s\n" "$ac_ct_OBJCOPY" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -38333,8 +40811,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     OBJCOPY=$ac_ct_OBJCOPY
-@@ -38350,8 +40828,8 @@ fi
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xOBJCOPY" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of OBJCOPY from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       if test -n "$ac_tool_prefix"; then
-@@ -38359,38 +40837,44 @@ $as_echo "$as_me: WARNING: Ignoring value of OBJCOPY from the environment. Use c
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_OBJCOPY+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$OBJCOPY"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_OBJCOPY+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$OBJCOPY"; then
-   ac_cv_prog_OBJCOPY="$OBJCOPY" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_OBJCOPY="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- OBJCOPY=$ac_cv_prog_OBJCOPY
- if test -n "$OBJCOPY"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
--$as_echo "$OBJCOPY" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
-+printf "%s\n" "$OBJCOPY" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -38403,38 +40887,44 @@ if test -z "$OBJCOPY"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_OBJCOPY+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_OBJCOPY"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_OBJCOPY+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_OBJCOPY"; then
-   ac_cv_prog_ac_ct_OBJCOPY="$ac_ct_OBJCOPY" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_OBJCOPY="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_OBJCOPY=$ac_cv_prog_ac_ct_OBJCOPY
- if test -n "$ac_ct_OBJCOPY"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJCOPY" >&5
--$as_echo "$ac_ct_OBJCOPY" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJCOPY" >&5
-+printf "%s\n" "$ac_ct_OBJCOPY" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -38446,8 +40936,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     OBJCOPY=$ac_ct_OBJCOPY
-@@ -38467,16 +40957,17 @@ fi
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJCOPY=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool OBJCOPY=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJCOPY=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool OBJCOPY=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_OBJCOPY+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $OBJCOPY in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_OBJCOPY+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $OBJCOPY in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_OBJCOPY="$OBJCOPY" # Let the user override the test with a path.
-   ;;
-@@ -38485,11 +40976,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_OBJCOPY="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_OBJCOPY="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -38497,15 +40992,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- OBJCOPY=$ac_cv_path_OBJCOPY
- if test -n "$OBJCOPY"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
--$as_echo "$OBJCOPY" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJCOPY" >&5
-+printf "%s\n" "$OBJCOPY" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -38514,17 +41010,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJCOPY=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool OBJCOPY=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJCOPY" >&5
--$as_echo_n "checking for OBJCOPY... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJCOPY=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool OBJCOPY=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for OBJCOPY" >&5
-+printf %s "checking for OBJCOPY... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool OBJCOPY=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -38573,12 +41069,12 @@ $as_echo "$tool_specified" >&6; }
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
-     fi
-@@ -38600,10 +41096,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of OBJCOPY, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of OBJCOPY, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
-     fi
-   else
-@@ -38713,12 +41209,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
-     fi
-@@ -38790,12 +41286,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of OBJCOPY, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of OBJCOPY" "$LINENO" 5
-     fi
-@@ -38810,8 +41306,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     OBJCOPY="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OBJCOPY to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting OBJCOPY to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting OBJCOPY to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting OBJCOPY to \"$new_complete\"" >&6;}
-   fi
- 
-     fi
-@@ -38829,38 +41325,44 @@ $as_echo "$as_me: Rewriting OBJCOPY to \"$new_complete\"" >&6;}
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_OBJDUMP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$OBJDUMP"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_OBJDUMP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$OBJDUMP"; then
-   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_OBJDUMP="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- OBJDUMP=$ac_cv_prog_OBJDUMP
- if test -n "$OBJDUMP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
--$as_echo "$OBJDUMP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
-+printf "%s\n" "$OBJDUMP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -38873,38 +41375,44 @@ if test -z "$OBJDUMP"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_OBJDUMP"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_OBJDUMP"; then
-   ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_OBJDUMP="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
- if test -n "$ac_ct_OBJDUMP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
--$as_echo "$ac_ct_OBJDUMP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
-+printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -38916,8 +41424,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     OBJDUMP=$ac_ct_OBJDUMP
-@@ -38933,8 +41441,8 @@ fi
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xOBJDUMP" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of OBJDUMP from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       if test -n "$ac_tool_prefix"; then
-@@ -38942,38 +41450,44 @@ $as_echo "$as_me: WARNING: Ignoring value of OBJDUMP from the environment. Use c
-   do
-     # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
- set dummy $ac_tool_prefix$ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_OBJDUMP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$OBJDUMP"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_OBJDUMP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$OBJDUMP"; then
-   ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_OBJDUMP="$ac_tool_prefix$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- OBJDUMP=$ac_cv_prog_OBJDUMP
- if test -n "$OBJDUMP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
--$as_echo "$OBJDUMP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
-+printf "%s\n" "$OBJDUMP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -38986,38 +41500,44 @@ if test -z "$OBJDUMP"; then
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$ac_ct_OBJDUMP"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_ac_ct_OBJDUMP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$ac_ct_OBJDUMP"; then
-   ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_ac_ct_OBJDUMP="$ac_prog"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
- if test -n "$ac_ct_OBJDUMP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
--$as_echo "$ac_ct_OBJDUMP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
-+printf "%s\n" "$ac_ct_OBJDUMP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -39029,8 +41549,8 @@ done
-   else
-     case $cross_compiling:$ac_tool_warned in
- yes:)
--{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
--$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
-+printf "%s\n" "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
- ac_tool_warned=yes ;;
- esac
-     OBJDUMP=$ac_ct_OBJDUMP
-@@ -39050,16 +41570,17 @@ fi
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJDUMP=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool OBJDUMP=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool OBJDUMP=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool OBJDUMP=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_OBJDUMP+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $OBJDUMP in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_OBJDUMP+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $OBJDUMP in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_OBJDUMP="$OBJDUMP" # Let the user override the test with a path.
-   ;;
-@@ -39068,11 +41589,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_OBJDUMP="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_OBJDUMP="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -39080,15 +41605,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- OBJDUMP=$ac_cv_path_OBJDUMP
- if test -n "$OBJDUMP"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
--$as_echo "$OBJDUMP" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
-+printf "%s\n" "$OBJDUMP" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -39097,17 +41623,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJDUMP=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool OBJDUMP=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for OBJDUMP" >&5
--$as_echo_n "checking for OBJDUMP... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool OBJDUMP=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool OBJDUMP=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for OBJDUMP" >&5
-+printf %s "checking for OBJDUMP... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool OBJDUMP=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -39157,12 +41683,12 @@ $as_echo "$tool_specified" >&6; }
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
-     fi
-@@ -39184,10 +41710,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of OBJDUMP, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of OBJDUMP, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
-     fi
-   else
-@@ -39297,12 +41823,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
-     fi
-@@ -39374,12 +41900,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of OBJDUMP, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of OBJDUMP" "$LINENO" 5
-     fi
-@@ -39394,8 +41920,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     OBJDUMP="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting OBJDUMP to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting OBJDUMP to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting OBJDUMP to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting OBJDUMP to \"$new_complete\"" >&6;}
-   fi
- 
-   fi
-@@ -39439,12 +41965,13 @@ $as_echo "$as_me: Rewriting OBJDUMP to \"$new_complete\"" >&6;}
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_CC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_CC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_CC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_CC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
-   ;;
-@@ -39453,11 +41980,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_CC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -39465,15 +41996,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_CC=$ac_cv_path_BUILD_CC
- if test -n "$BUILD_CC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
--$as_echo "$BUILD_CC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
-+printf "%s\n" "$BUILD_CC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -39489,20 +42021,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xBUILD_CC" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in clang cl cc gcc
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_CC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_CC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_CC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_CC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
-   ;;
-@@ -39511,11 +42044,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_CC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -39523,15 +42060,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_CC=$ac_cv_path_BUILD_CC
- if test -n "$BUILD_CC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
--$as_echo "$BUILD_CC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
-+printf "%s\n" "$BUILD_CC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -39551,16 +42089,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CC=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool BUILD_CC=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CC=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool BUILD_CC=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_CC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_CC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_CC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_CC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
-   ;;
-@@ -39569,11 +42108,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_CC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -39581,15 +42124,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_CC=$ac_cv_path_BUILD_CC
- if test -n "$BUILD_CC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
--$as_echo "$BUILD_CC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
-+printf "%s\n" "$BUILD_CC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -39598,17 +42142,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CC=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool BUILD_CC=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CC" >&5
--$as_echo_n "checking for BUILD_CC... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CC=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool BUILD_CC=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BUILD_CC" >&5
-+printf %s "checking for BUILD_CC... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool BUILD_CC=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -39625,12 +42169,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_CXX+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_CXX in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_CXX+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_CXX in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
-   ;;
-@@ -39639,11 +42184,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_CXX="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -39651,15 +42200,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_CXX=$ac_cv_path_BUILD_CXX
- if test -n "$BUILD_CXX"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
--$as_echo "$BUILD_CXX" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
-+printf "%s\n" "$BUILD_CXX" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -39675,20 +42225,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xBUILD_CXX" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in clang++ cl CC g++
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_CXX+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_CXX in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_CXX+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_CXX in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
-   ;;
-@@ -39697,11 +42248,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_CXX="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -39709,15 +42264,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_CXX=$ac_cv_path_BUILD_CXX
- if test -n "$BUILD_CXX"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
--$as_echo "$BUILD_CXX" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
-+printf "%s\n" "$BUILD_CXX" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -39737,16 +42293,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CXX=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool BUILD_CXX=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CXX=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool BUILD_CXX=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_CXX+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_CXX in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_CXX+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_CXX in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
-   ;;
-@@ -39755,11 +42312,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_CXX="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -39767,15 +42328,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_CXX=$ac_cv_path_BUILD_CXX
- if test -n "$BUILD_CXX"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
--$as_echo "$BUILD_CXX" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
-+printf "%s\n" "$BUILD_CXX" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -39784,17 +42346,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CXX=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool BUILD_CXX=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CXX" >&5
--$as_echo_n "checking for BUILD_CXX... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CXX=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool BUILD_CXX=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BUILD_CXX" >&5
-+printf %s "checking for BUILD_CXX... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool BUILD_CXX=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -39813,12 +42375,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_CC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_CC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_CC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_CC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
-   ;;
-@@ -39827,11 +42390,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_CC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -39839,15 +42406,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_CC=$ac_cv_path_BUILD_CC
- if test -n "$BUILD_CC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
--$as_echo "$BUILD_CC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
-+printf "%s\n" "$BUILD_CC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -39863,20 +42431,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xBUILD_CC" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of BUILD_CC from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in cl cc gcc
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_CC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_CC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_CC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_CC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
-   ;;
-@@ -39885,11 +42454,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_CC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -39897,15 +42470,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_CC=$ac_cv_path_BUILD_CC
- if test -n "$BUILD_CC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
--$as_echo "$BUILD_CC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
-+printf "%s\n" "$BUILD_CC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -39925,16 +42499,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CC=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool BUILD_CC=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CC=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool BUILD_CC=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_CC+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_CC in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_CC+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_CC in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_CC="$BUILD_CC" # Let the user override the test with a path.
-   ;;
-@@ -39943,11 +42518,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_CC="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_CC="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -39955,15 +42534,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_CC=$ac_cv_path_BUILD_CC
- if test -n "$BUILD_CC"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
--$as_echo "$BUILD_CC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CC" >&5
-+printf "%s\n" "$BUILD_CC" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -39972,17 +42552,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CC=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool BUILD_CC=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CC" >&5
--$as_echo_n "checking for BUILD_CC... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CC=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool BUILD_CC=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BUILD_CC" >&5
-+printf %s "checking for BUILD_CC... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool BUILD_CC=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -40006,12 +42586,13 @@ $as_echo "$tool_specified" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_CXX+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_CXX in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_CXX+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_CXX in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
-   ;;
-@@ -40020,11 +42601,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_CXX="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -40032,15 +42617,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_CXX=$ac_cv_path_BUILD_CXX
- if test -n "$BUILD_CXX"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
--$as_echo "$BUILD_CXX" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
-+printf "%s\n" "$BUILD_CXX" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -40056,20 +42642,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xBUILD_CXX" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of BUILD_CXX from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in cl CC g++
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_CXX+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_CXX in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_CXX+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_CXX in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
-   ;;
-@@ -40078,11 +42665,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_CXX="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -40090,15 +42681,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_CXX=$ac_cv_path_BUILD_CXX
- if test -n "$BUILD_CXX"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
--$as_echo "$BUILD_CXX" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
-+printf "%s\n" "$BUILD_CXX" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -40118,16 +42710,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CXX=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool BUILD_CXX=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_CXX=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool BUILD_CXX=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_CXX+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_CXX in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_CXX+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_CXX in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_CXX="$BUILD_CXX" # Let the user override the test with a path.
-   ;;
-@@ -40136,11 +42729,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_CXX="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_CXX="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -40148,15 +42745,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_CXX=$ac_cv_path_BUILD_CXX
- if test -n "$BUILD_CXX"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
--$as_echo "$BUILD_CXX" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_CXX" >&5
-+printf "%s\n" "$BUILD_CXX" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -40165,17 +42763,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CXX=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool BUILD_CXX=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_CXX" >&5
--$as_echo_n "checking for BUILD_CXX... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_CXX=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool BUILD_CXX=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BUILD_CXX" >&5
-+printf %s "checking for BUILD_CXX... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool BUILD_CXX=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -40229,12 +42827,12 @@ $as_echo "$tool_specified" >&6; }
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
-     fi
-@@ -40256,10 +42854,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of BUILD_CC, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BUILD_CC, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
-     fi
-   else
-@@ -40369,12 +42967,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
-     fi
-@@ -40446,12 +43044,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of BUILD_CC, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of BUILD_CC" "$LINENO" 5
-     fi
-@@ -40466,8 +43064,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     BUILD_CC="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CC to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting BUILD_CC to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CC to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting BUILD_CC to \"$new_complete\"" >&6;}
-   fi
- 
- 
-@@ -40511,12 +43109,12 @@ $as_echo "$as_me: Rewriting BUILD_CC to \"$new_complete\"" >&6;}
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
-     fi
-@@ -40538,10 +43136,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BUILD_CXX, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
-     fi
-   else
-@@ -40651,12 +43249,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
-     fi
-@@ -40728,12 +43326,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of BUILD_CXX, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of BUILD_CXX" "$LINENO" 5
-     fi
-@@ -40748,8 +43346,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     BUILD_CXX="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CXX to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting BUILD_CXX to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_CXX to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting BUILD_CXX to \"$new_complete\"" >&6;}
-   fi
- 
- 
-@@ -40763,12 +43361,13 @@ $as_echo "$as_me: Rewriting BUILD_CXX to \"$new_complete\"" >&6;}
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_LD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_LD in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_LD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_LD in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_LD="$BUILD_LD" # Let the user override the test with a path.
-   ;;
-@@ -40777,11 +43376,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_LD="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_LD="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -40789,15 +43392,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_LD=$ac_cv_path_BUILD_LD
- if test -n "$BUILD_LD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
--$as_echo "$BUILD_LD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
-+printf "%s\n" "$BUILD_LD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -40813,20 +43417,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xBUILD_LD" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_LD from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of BUILD_LD from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of BUILD_LD from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of BUILD_LD from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in ld
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_LD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_LD in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_LD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_LD in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_LD="$BUILD_LD" # Let the user override the test with a path.
-   ;;
-@@ -40835,11 +43440,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_LD="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_LD="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -40847,15 +43456,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_LD=$ac_cv_path_BUILD_LD
- if test -n "$BUILD_LD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
--$as_echo "$BUILD_LD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
-+printf "%s\n" "$BUILD_LD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -40875,16 +43485,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_LD=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool BUILD_LD=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool BUILD_LD=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool BUILD_LD=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_BUILD_LD+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $BUILD_LD in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_BUILD_LD+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $BUILD_LD in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_BUILD_LD="$BUILD_LD" # Let the user override the test with a path.
-   ;;
-@@ -40893,11 +43504,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_BUILD_LD="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_BUILD_LD="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -40905,15 +43520,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- BUILD_LD=$ac_cv_path_BUILD_LD
- if test -n "$BUILD_LD"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
--$as_echo "$BUILD_LD" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $BUILD_LD" >&5
-+printf "%s\n" "$BUILD_LD" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -40922,17 +43538,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_LD=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool BUILD_LD=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for BUILD_LD" >&5
--$as_echo_n "checking for BUILD_LD... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool BUILD_LD=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool BUILD_LD=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for BUILD_LD" >&5
-+printf %s "checking for BUILD_LD... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool BUILD_LD=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -40979,12 +43595,12 @@ $as_echo "$tool_specified" >&6; }
-     fi
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of BUILD_LD" "$LINENO" 5
-     fi
-@@ -41006,10 +43622,10 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     elif test -f "${new_path}.cmd"; then
-       input_to_shortpath="${new_path}.cmd"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$new_path\", is invalid." >&5
--$as_echo "$as_me: The path of BUILD_LD, which resolves as \"$new_path\", is invalid." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
--$as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$new_path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of BUILD_LD, which resolves as \"$new_path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&5
-+printf "%s\n" "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found" >&6;}
-       as_fn_error $? "Cannot locate the the path of BUILD_LD" "$LINENO" 5
-     fi
-   else
-@@ -41119,12 +43735,12 @@ $as_echo "$as_me: Neither \"$new_path\" nor \"$new_path.exe/cmd\" can be found"
- 
-     if test "x$new_path" = x; then
-       # It's still not found. Now this is an unrecoverable error.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
--$as_echo "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You might be mixing spaces in the path and extra arguments, which is not allowed." >&5
-+printf "%s\n" "$as_me: You might be mixing spaces in the path and extra arguments, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of BUILD_LD" "$LINENO" 5
-     fi
-@@ -41196,12 +43812,12 @@ $as_echo "$as_me: You might be mixing spaces in the path and extra arguments, wh
-     fi
- 
-     if test "x$new_path" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
--$as_echo "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&5
-+printf "%s\n" "$as_me: The path of BUILD_LD, which resolves as \"$complete\", is not found." >&6;}
-       has_space=`$ECHO "$complete" | $GREP " "`
-       if test "x$has_space" != x; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
--$as_echo "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: This might be caused by spaces in the path, which is not allowed." >&5
-+printf "%s\n" "$as_me: This might be caused by spaces in the path, which is not allowed." >&6;}
-       fi
-       as_fn_error $? "Cannot locate the the path of BUILD_LD" "$LINENO" 5
-     fi
-@@ -41216,8 +43832,8 @@ $as_echo "$as_me: This might be caused by spaces in the path, which is not allow
- 
-   if test "x$complete" != "x$new_complete"; then
-     BUILD_LD="$new_complete"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_LD to \"$new_complete\"" >&5
--$as_echo "$as_me: Rewriting BUILD_LD to \"$new_complete\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting BUILD_LD to \"$new_complete\"" >&5
-+printf "%s\n" "$as_me: Rewriting BUILD_LD to \"$new_complete\"" >&6;}
-   fi
- 
-   else
-@@ -41327,11 +43943,11 @@ $as_echo "$as_me: Rewriting BUILD_LD to \"$new_complete\"" >&6;}
- 
-   if test "x$TOOLCHAIN_TYPE" = xgcc; then
-     if test "x$OPENJDK_TARGET_CPU_ARCH" = "xaarch64" ; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for broken aarch64 gcc 4.x" >&5
--$as_echo_n "checking for broken aarch64 gcc 4.x... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for broken aarch64 gcc 4.x" >&5
-+printf %s "checking for broken aarch64 gcc 4.x... " >&6; }
-       COMPILER_VERSION_NUMBER_MAJOR=`$ECHO "$COMPILER_VERSION_NUMBER" | $SED  "s/[^0-9].*//"`
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: found $COMPILER_VERSION_NUMBER_MAJOR.x" >&5
--$as_echo "found $COMPILER_VERSION_NUMBER_MAJOR.x" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: found $COMPILER_VERSION_NUMBER_MAJOR.x" >&5
-+printf "%s\n" "found $COMPILER_VERSION_NUMBER_MAJOR.x" >&6; }
-       if test $COMPILER_VERSION_NUMBER_MAJOR -lt 5; then
-         as_fn_error $? "GCC < 5 may incorrectly compile HotSpot on aarch64. See JDK-8360869." "$LINENO" 5
-       fi
-@@ -41342,17 +43958,17 @@ $as_echo "found $COMPILER_VERSION_NUMBER_MAJOR.x" >&6; }
-   # in executable.'
-   USING_BROKEN_SUSE_LD=no
-   if test "x$OPENJDK_TARGET_OS" = xlinux && test "x$TOOLCHAIN_TYPE" = xgcc; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for broken SuSE 'ld' which only understands anonymous version tags in executables" >&5
--$as_echo_n "checking for broken SuSE 'ld' which only understands anonymous version tags in executables... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for broken SuSE 'ld' which only understands anonymous version tags in executables" >&5
-+printf %s "checking for broken SuSE 'ld' which only understands anonymous version tags in executables... " >&6; }
-     echo "SUNWprivate_1.1 { local: *; };" > version-script.map
-     echo "int main() { }" > main.c
-     if $CXX -Xlinker -version-script=version-script.map main.c 2>&5 >&5; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-       USING_BROKEN_SUSE_LD=no
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
-       USING_BROKEN_SUSE_LD=yes
-     fi
-     rm -rf version-script.map main.c
-@@ -41364,19 +43980,21 @@ $as_echo "yes" >&6; }
- 
- 
- # Check whether --with-jtreg was given.
--if test "${with_jtreg+set}" = set; then :
-+if test ${with_jtreg+y}
-+then :
-   withval=$with_jtreg;
--else
--  with_jtreg=no
-+else case e in #(
-+  e) with_jtreg=no ;;
-+esac
- fi
- 
- 
-   if test "x$with_jtreg" = xno; then
-     # jtreg disabled
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jtreg" >&5
--$as_echo_n "checking for jtreg... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for jtreg" >&5
-+printf %s "checking for jtreg... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-   else
-     if test "x$with_jtreg" != xyes; then
-       # with path specified.
-@@ -41384,8 +44002,8 @@ $as_echo "no" >&6; }
-     fi
- 
-     if test "x$JT_HOME" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for jtreg" >&5
--$as_echo_n "checking for jtreg... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for jtreg" >&5
-+printf %s "checking for jtreg... " >&6; }
- 
-       # use JT_HOME enviroment var.
- 
-@@ -41408,8 +44026,8 @@ $as_echo_n "checking for jtreg... " >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of JT_HOME" "$LINENO" 5
-   fi
- 
-@@ -41457,8 +44075,8 @@ $as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid."
- 
-   if test "x$path" != "x$new_path"; then
-     JT_HOME="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -41495,8 +44113,8 @@ $as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     JT_HOME="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting JT_HOME to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -41507,8 +44125,8 @@ $as_echo "$as_me: Rewriting JT_HOME to \"$new_path\"" >&6;}
-     path="$JT_HOME"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of JT_HOME, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -41529,8 +44147,8 @@ $as_echo "$as_me: The path of JT_HOME, which resolves as \"$path\", is invalid."
-         as_fn_error $? "JTReg executable does not exist: $JTREGEXE" "$LINENO" 5
-       fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
--$as_echo "$JTREGEXE" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
-+printf "%s\n" "$JTREGEXE" >&6; }
-     else
-       # try to find jtreg on path
- 
-@@ -41545,12 +44163,13 @@ $as_echo "$JTREGEXE" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_JTREGEXE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $JTREGEXE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_JTREGEXE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $JTREGEXE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
-   ;;
-@@ -41559,11 +44178,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_JTREGEXE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -41571,15 +44194,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- JTREGEXE=$ac_cv_path_JTREGEXE
- if test -n "$JTREGEXE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
--$as_echo "$JTREGEXE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
-+printf "%s\n" "$JTREGEXE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -41595,20 +44219,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xJTREGEXE" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of JTREGEXE from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in jtreg
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_JTREGEXE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $JTREGEXE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_JTREGEXE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $JTREGEXE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
-   ;;
-@@ -41617,11 +44242,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_JTREGEXE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -41629,15 +44258,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- JTREGEXE=$ac_cv_path_JTREGEXE
- if test -n "$JTREGEXE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
--$as_echo "$JTREGEXE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
-+printf "%s\n" "$JTREGEXE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -41657,16 +44287,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JTREGEXE=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool JTREGEXE=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool JTREGEXE=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool JTREGEXE=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_JTREGEXE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $JTREGEXE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_JTREGEXE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $JTREGEXE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_JTREGEXE="$JTREGEXE" # Let the user override the test with a path.
-   ;;
-@@ -41675,11 +44306,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_JTREGEXE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_JTREGEXE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -41687,15 +44322,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- JTREGEXE=$ac_cv_path_JTREGEXE
- if test -n "$JTREGEXE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
--$as_echo "$JTREGEXE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JTREGEXE" >&5
-+printf "%s\n" "$JTREGEXE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -41704,17 +44340,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JTREGEXE=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool JTREGEXE=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for JTREGEXE" >&5
--$as_echo_n "checking for JTREGEXE... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool JTREGEXE=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool JTREGEXE=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for JTREGEXE" >&5
-+printf %s "checking for JTREGEXE... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool JTREGEXE=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -41864,137 +44500,36 @@ $as_echo "$tool_specified" >&6; }
- 
- # Now we can test some aspects on the target using configure macros.
- 
-+ac_header= ac_cache=
-+for ac_item in $ac_header_cxx_list
-+do
-+  if test $ac_cache; then
-+    ac_fn_cxx_check_header_compile "$LINENO" $ac_header ac_cv_header_$ac_cache "$ac_includes_default"
-+    if eval test \"x\$ac_cv_header_$ac_cache\" = xyes; then
-+      printf "%s\n" "#define $ac_item 1" >> confdefs.h
-+    fi
-+    ac_header= ac_cache=
-+  elif test $ac_header; then
-+    ac_cache=$ac_item
-+  else
-+    ac_header=$ac_item
-+  fi
-+done
- 
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
--$as_echo_n "checking for ANSI C header files... " >&6; }
--if ${ac_cv_header_stdc+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
--/* end confdefs.h.  */
--#include <stdlib.h>
--#include <stdarg.h>
--#include <string.h>
--#include <float.h>
--
--int
--main ()
--{
--
--  ;
--  return 0;
--}
--_ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
--  ac_cv_header_stdc=yes
--else
--  ac_cv_header_stdc=no
--fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
--
--if test $ac_cv_header_stdc = yes; then
--  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
--  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
--/* end confdefs.h.  */
--#include <string.h>
--
--_ACEOF
--if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
--  $EGREP "memchr" >/dev/null 2>&1; then :
--
--else
--  ac_cv_header_stdc=no
--fi
--rm -f conftest*
--
--fi
--
--if test $ac_cv_header_stdc = yes; then
--  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
--  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
--/* end confdefs.h.  */
--#include <stdlib.h>
--
--_ACEOF
--if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
--  $EGREP "free" >/dev/null 2>&1; then :
--
--else
--  ac_cv_header_stdc=no
--fi
--rm -f conftest*
- 
--fi
- 
--if test $ac_cv_header_stdc = yes; then
--  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
--  if test "$cross_compiling" = yes; then :
--  :
--else
--  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
--/* end confdefs.h.  */
--#include <ctype.h>
--#include <stdlib.h>
--#if ((' ' & 0x0FF) == 0x020)
--# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
--# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
--#else
--# define ISLOWER(c) \
--		   (('a' <= (c) && (c) <= 'i') \
--		     || ('j' <= (c) && (c) <= 'r') \
--		     || ('s' <= (c) && (c) <= 'z'))
--# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
--#endif
- 
--#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
--int
--main ()
--{
--  int i;
--  for (i = 0; i < 256; i++)
--    if (XOR (islower (i), ISLOWER (i))
--	|| toupper (i) != TOUPPER (i))
--      return 2;
--  return 0;
--}
--_ACEOF
--if ac_fn_cxx_try_run "$LINENO"; then :
- 
--else
--  ac_cv_header_stdc=no
--fi
--rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
--  conftest.$ac_objext conftest.beam conftest.$ac_ext
--fi
- 
--fi
--fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
--$as_echo "$ac_cv_header_stdc" >&6; }
--if test $ac_cv_header_stdc = yes; then
- 
--$as_echo "#define STDC_HEADERS 1" >>confdefs.h
- 
--fi
-+if test $ac_cv_header_stdlib_h = yes && test $ac_cv_header_string_h = yes
-+then :
- 
--# On IRIX 5.3, sys/types and inttypes.h are conflicting.
--for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
--		  inttypes.h stdint.h unistd.h
--do :
--  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
--ac_fn_cxx_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
--"
--if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
--  cat >>confdefs.h <<_ACEOF
--#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
--_ACEOF
-+printf "%s\n" "#define STDC_HEADERS 1" >>confdefs.h
- 
- fi
- 
--done
--
--
--
-   ###############################################################################
-   #
-   # Now we check if libjvm.so will use 32 or 64 bit pointers for the C/C++ code.
-@@ -42046,81 +44581,82 @@ done
-   fi
- 
-   # Make compilation sanity check
--  for ac_header in stdio.h
-+         for ac_header in stdio.h
- do :
--  ac_fn_cxx_check_header_mongrel "$LINENO" "stdio.h" "ac_cv_header_stdio_h" "$ac_includes_default"
--if test "x$ac_cv_header_stdio_h" = xyes; then :
--  cat >>confdefs.h <<_ACEOF
--#define HAVE_STDIO_H 1
--_ACEOF
--
--else
--
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Failed to compile stdio.h. This likely implies missing compile dependencies." >&5
--$as_echo "$as_me: Failed to compile stdio.h. This likely implies missing compile dependencies." >&6;}
-+  ac_fn_cxx_check_header_compile "$LINENO" "stdio.h" "ac_cv_header_stdio_h" "$ac_includes_default"
-+if test "x$ac_cv_header_stdio_h" = xyes
-+then :
-+  printf "%s\n" "#define HAVE_STDIO_H 1" >>confdefs.h
-+
-+else case e in #(
-+  e)
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Failed to compile stdio.h. This likely implies missing compile dependencies." >&5
-+printf "%s\n" "$as_me: Failed to compile stdio.h. This likely implies missing compile dependencies." >&6;}
-     if test "x$COMPILE_TYPE" = xreduced; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: You are doing a reduced build. Check that you have 32-bit libraries installed." >&5
--$as_echo "$as_me: You are doing a reduced build. Check that you have 32-bit libraries installed." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You are doing a reduced build. Check that you have 32-bit libraries installed." >&5
-+printf "%s\n" "$as_me: You are doing a reduced build. Check that you have 32-bit libraries installed." >&6;}
-     elif test "x$COMPILE_TYPE" = xcross; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&5
--$as_echo "$as_me: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&5
-+printf "%s\n" "$as_me: You are doing a cross-compilation. Check that you have all target platform libraries installed." >&6;}
-     fi
-     as_fn_error $? "Cannot continue." "$LINENO" 5
--
-+   ;;
-+esac
- fi
- 
- done
- 
--
-   # The cast to long int works around a bug in the HP C Compiler
- # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
--# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
-+# declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'.
- # This bug is HP SR number 8606223364.
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5
--$as_echo_n "checking size of int *... " >&6; }
--if ${ac_cv_sizeof_int_p+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p"        "$ac_includes_default"; then :
--
--else
--  if test "$ac_cv_type_int_p" = yes; then
--     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
--$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5
-+printf %s "checking size of int *... " >&6; }
-+if test ${ac_cv_sizeof_int_p+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p"        "$ac_includes_default"
-+then :
-+
-+else case e in #(
-+  e) if test "$ac_cv_type_int_p" = yes; then
-+     { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
- as_fn_error 77 "cannot compute sizeof (int *)
--See \`config.log' for more details" "$LINENO" 5; }
-+See 'config.log' for more details" "$LINENO" 5; }
-    else
-      ac_cv_sizeof_int_p=0
--   fi
-+   fi ;;
-+esac
- fi
--
-+ ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5
--$as_echo "$ac_cv_sizeof_int_p" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5
-+printf "%s\n" "$ac_cv_sizeof_int_p" >&6; }
- 
- 
- 
--cat >>confdefs.h <<_ACEOF
--#define SIZEOF_INT_P $ac_cv_sizeof_int_p
--_ACEOF
-+printf "%s\n" "#define SIZEOF_INT_P $ac_cv_sizeof_int_p" >>confdefs.h
- 
- 
- 
-   # AC_CHECK_SIZEOF defines 'ac_cv_sizeof_int_p' to hold the number of bytes used by an 'int*'
-   if test "x$ac_cv_sizeof_int_p" = x; then
-     # The test failed, lets stick to the assumed value.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The number of bits in the target could not be determined, using $OPENJDK_TARGET_CPU_BITS." >&5
--$as_echo "$as_me: WARNING: The number of bits in the target could not be determined, using $OPENJDK_TARGET_CPU_BITS." >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: The number of bits in the target could not be determined, using $OPENJDK_TARGET_CPU_BITS." >&5
-+printf "%s\n" "$as_me: WARNING: The number of bits in the target could not be determined, using $OPENJDK_TARGET_CPU_BITS." >&2;}
-   else
-     TESTED_TARGET_CPU_BITS=`expr 8 \* $ac_cv_sizeof_int_p`
- 
-     if test "x$TESTED_TARGET_CPU_BITS" != "x$OPENJDK_TARGET_CPU_BITS"; then
-       # This situation may happen on 64-bit platforms where the compiler by default only generates 32-bit objects
-       # Let's try to implicitely set the compilers target architecture and retry the test
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)." >&5
--$as_echo "$as_me: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)." >&6;}
--      { $as_echo "$as_me:${as_lineno-$LINENO}: I'll retry after setting the platforms compiler target bits flag to ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" >&5
--$as_echo "$as_me: I'll retry after setting the platforms compiler target bits flag to ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)." >&5
-+printf "%s\n" "$as_me: The tested number of bits in the target ($TESTED_TARGET_CPU_BITS) differs from the number of bits expected to be found in the target ($OPENJDK_TARGET_CPU_BITS)." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: I'll retry after setting the platforms compiler target bits flag to ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" >&5
-+printf "%s\n" "$as_me: I'll retry after setting the platforms compiler target bits flag to ${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}" >&6;}
- 
-   # When we add flags to the "official" CFLAGS etc, we need to
-   # keep track of these additions in ADDED_CFLAGS etc. These
-@@ -42148,35 +44684,37 @@ _ACEOF
- 
-       # The cast to long int works around a bug in the HP C Compiler
- # version HP92453-01 B.11.11.23709.GP, which incorrectly rejects
--# declarations like `int a3[[(sizeof (unsigned char)) >= 0]];'.
-+# declarations like 'int a3[[(sizeof (unsigned char)) >= 0]];'.
- # This bug is HP SR number 8606223364.
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5
--$as_echo_n "checking size of int *... " >&6; }
--if ${ac_cv_sizeof_int_p+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p"        "$ac_includes_default"; then :
--
--else
--  if test "$ac_cv_type_int_p" = yes; then
--     { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
--$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking size of int *" >&5
-+printf %s "checking size of int *... " >&6; }
-+if test ${ac_cv_sizeof_int_p+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if ac_fn_cxx_compute_int "$LINENO" "(long int) (sizeof (int *))" "ac_cv_sizeof_int_p"        "$ac_includes_default"
-+then :
-+
-+else case e in #(
-+  e) if test "$ac_cv_type_int_p" = yes; then
-+     { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
- as_fn_error 77 "cannot compute sizeof (int *)
--See \`config.log' for more details" "$LINENO" 5; }
-+See 'config.log' for more details" "$LINENO" 5; }
-    else
-      ac_cv_sizeof_int_p=0
--   fi
-+   fi ;;
-+esac
- fi
--
-+ ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5
--$as_echo "$ac_cv_sizeof_int_p" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_sizeof_int_p" >&5
-+printf "%s\n" "$ac_cv_sizeof_int_p" >&6; }
- 
- 
- 
--cat >>confdefs.h <<_ACEOF
--#define SIZEOF_INT_P $ac_cv_sizeof_int_p
--_ACEOF
-+printf "%s\n" "#define SIZEOF_INT_P $ac_cv_sizeof_int_p" >>confdefs.h
- 
- 
- 
-@@ -42188,22 +44726,23 @@ _ACEOF
-     fi
-   fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for target address size" >&5
--$as_echo_n "checking for target address size... " >&6; }
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_CPU_BITS bits" >&5
--$as_echo "$OPENJDK_TARGET_CPU_BITS bits" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for target address size" >&5
-+printf %s "checking for target address size... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OPENJDK_TARGET_CPU_BITS bits" >&5
-+printf "%s\n" "$OPENJDK_TARGET_CPU_BITS bits" >&6; }
- 
- 
-   ###############################################################################
-   #
-   # Is the target little of big endian?
-   #
--   { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
--$as_echo_n "checking whether byte ordering is bigendian... " >&6; }
--if ${ac_cv_c_bigendian+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_cv_c_bigendian=unknown
-+   { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether byte ordering is bigendian" >&5
-+printf %s "checking whether byte ordering is bigendian... " >&6; }
-+if test ${ac_cv_c_bigendian+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_cv_c_bigendian=unknown
-     # See if we're dealing with a universal compiler.
-     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
-@@ -42213,7 +44752,8 @@ else
- 	     typedef int dummy;
- 
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
- 
- 	# Check for potential -arch flags.  It is not universal unless
- 	# there are at least two -arch flags with different values.
-@@ -42237,7 +44777,7 @@ if ac_fn_cxx_try_compile "$LINENO"; then :
- 	 fi
-        done
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-     if test $ac_cv_c_bigendian = unknown; then
-       # See if sys/param.h defines the BYTE_ORDER macro.
-       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-@@ -42246,10 +44786,10 @@ rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
- 	     #include <sys/param.h>
- 
- int
--main ()
-+main (void)
- {
--#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \
--		     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \
-+#if ! (defined BYTE_ORDER && defined BIG_ENDIAN \\
-+		     && defined LITTLE_ENDIAN && BYTE_ORDER && BIG_ENDIAN \\
- 		     && LITTLE_ENDIAN)
- 	      bogus endian macros
- 	     #endif
-@@ -42258,7 +44798,8 @@ main ()
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-   # It does; now see whether it defined to BIG_ENDIAN or not.
- 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
-@@ -42266,7 +44807,7 @@ if ac_fn_cxx_try_compile "$LINENO"; then :
- 		#include <sys/param.h>
- 
- int
--main ()
-+main (void)
- {
- #if BYTE_ORDER != BIG_ENDIAN
- 		 not big endian
-@@ -42276,14 +44817,16 @@ main ()
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-   ac_cv_c_bigendian=yes
--else
--  ac_cv_c_bigendian=no
-+else case e in #(
-+  e) ac_cv_c_bigendian=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-     fi
-     if test $ac_cv_c_bigendian = unknown; then
-       # See if <limits.h> defines _LITTLE_ENDIAN or _BIG_ENDIAN (e.g., Solaris).
-@@ -42292,7 +44835,7 @@ rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
- #include <limits.h>
- 
- int
--main ()
-+main (void)
- {
- #if ! (defined _LITTLE_ENDIAN || defined _BIG_ENDIAN)
- 	      bogus endian macros
-@@ -42302,14 +44845,15 @@ main ()
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-   # It does; now see whether it defined to _BIG_ENDIAN or not.
- 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- #include <limits.h>
- 
- int
--main ()
-+main (void)
- {
- #ifndef _BIG_ENDIAN
- 		 not big endian
-@@ -42319,50 +44863,55 @@ main ()
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-   ac_cv_c_bigendian=yes
--else
--  ac_cv_c_bigendian=no
-+else case e in #(
-+  e) ac_cv_c_bigendian=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-     fi
-     if test $ac_cv_c_bigendian = unknown; then
-       # Compile a test program.
--      if test "$cross_compiling" = yes; then :
-+      if test "$cross_compiling" = yes
-+then :
-   # Try to guess by grepping values from an object file.
- 	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
--short int ascii_mm[] =
-+unsigned short int ascii_mm[] =
- 		  { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
--		short int ascii_ii[] =
-+		unsigned short int ascii_ii[] =
- 		  { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
- 		int use_ascii (int i) {
- 		  return ascii_mm[i] + ascii_ii[i];
- 		}
--		short int ebcdic_ii[] =
-+		unsigned short int ebcdic_ii[] =
- 		  { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
--		short int ebcdic_mm[] =
-+		unsigned short int ebcdic_mm[] =
- 		  { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
- 		int use_ebcdic (int i) {
- 		  return ebcdic_mm[i] + ebcdic_ii[i];
- 		}
--		extern int foo;
--
--int
--main ()
--{
--return use_ascii (foo) == use_ebcdic (foo);
--  ;
--  return 0;
--}
-+		int
-+		main (int argc, char **argv)
-+		{
-+		  /* Intimidate the compiler so that it does not
-+		     optimize the arrays away.  */
-+		  char *p = argv[0];
-+		  ascii_mm[1] = *p++; ebcdic_mm[1] = *p++;
-+		  ascii_ii[1] = *p++; ebcdic_ii[1] = *p++;
-+		  return use_ascii (argc) == use_ebcdic (*p);
-+		}
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
--  if grep BIGenDianSyS conftest.$ac_objext >/dev/null; then
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-+  if grep BIGenDianSyS conftest$ac_exeext >/dev/null; then
- 	      ac_cv_c_bigendian=yes
- 	    fi
--	    if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
-+	    if grep LiTTleEnDian conftest$ac_exeext >/dev/null ; then
- 	      if test "$ac_cv_c_bigendian" = unknown; then
- 		ac_cv_c_bigendian=no
- 	      else
-@@ -42371,13 +44920,14 @@ if ac_fn_cxx_try_compile "$LINENO"; then :
- 	      fi
- 	    fi
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
--else
--  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-+    conftest$ac_exeext conftest.$ac_ext
-+else case e in #(
-+  e) cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- $ac_includes_default
- int
--main ()
-+main (void)
- {
- 
- 	     /* Are we little or big endian?  From Harbison&Steele.  */
-@@ -42393,19 +44943,23 @@ main ()
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_run "$LINENO"; then :
-+if ac_fn_cxx_try_run "$LINENO"
-+then :
-   ac_cv_c_bigendian=no
--else
--  ac_cv_c_bigendian=yes
-+else case e in #(
-+  e) ac_cv_c_bigendian=yes ;;
-+esac
- fi
- rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
--  conftest.$ac_objext conftest.beam conftest.$ac_ext
-+  conftest.$ac_objext conftest.beam conftest.$ac_ext ;;
-+esac
- fi
- 
--    fi
-+    fi ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
--$as_echo "$ac_cv_c_bigendian" >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_bigendian" >&5
-+printf "%s\n" "$ac_cv_c_bigendian" >&6; }
-  case $ac_cv_c_bigendian in #(
-    yes)
-      ENDIAN="big";; #(
-@@ -42657,8 +45211,8 @@ $as_echo "$ac_cv_c_bigendian" >&6; }
-     fi
-     CXXSTD_CXXFLAG="-std=gnu++98"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$CXXSTD_CXXFLAG -Werror\"" >&5
--$as_echo_n "checking if the C++ compiler supports \"$CXXSTD_CXXFLAG -Werror\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$CXXSTD_CXXFLAG -Werror\"" >&5
-+printf %s "checking if the C++ compiler supports \"$CXXSTD_CXXFLAG -Werror\"... " >&6; }
-   supports=yes
- 
-   saved_cxxflags="$CXXFLAGS"
-@@ -42673,12 +45227,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -42687,8 +45243,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CXXFLAGS="$saved_cxxflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     :
-   else
-@@ -42701,63 +45257,73 @@ $as_echo "$supports" >&6; }
-   fi
- 
-   if test "x$CFLAGS" != "x${ADDED_CFLAGS}"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags" >&5
--$as_echo "$as_me: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags" >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags" >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring CFLAGS($CFLAGS) found in environment. Use --with-extra-cflags" >&2;}
-   fi
- 
-   if test "x$CXXFLAGS" != "x${ADDED_CXXFLAGS}"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags" >&5
--$as_echo "$as_me: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags" >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags" >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring CXXFLAGS($CXXFLAGS) found in environment. Use --with-extra-cxxflags" >&2;}
-   fi
- 
-   if test "x$LDFLAGS" != "x${ADDED_LDFLAGS}"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags" >&5
--$as_echo "$as_me: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags" >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags" >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring LDFLAGS($LDFLAGS) found in environment. Use --with-extra-ldflags" >&2;}
-   fi
- 
- 
-   if test "x$ASFLAGS" != "x"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring ASFLAGS($ASFLAGS) found in environment. Use --with-extra-asflags" >&5
--$as_echo "$as_me: WARNING: Ignoring ASFLAGS($ASFLAGS) found in environment. Use --with-extra-asflags" >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring ASFLAGS($ASFLAGS) found in environment. Use --with-extra-asflags" >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring ASFLAGS($ASFLAGS) found in environment. Use --with-extra-asflags" >&2;}
-   fi
- 
- 
- # Check whether --with-extra-cflags was given.
--if test "${with_extra_cflags+set}" = set; then :
-+if test ${with_extra_cflags+y}
-+then :
-   withval=$with_extra_cflags;
- fi
- 
- 
- 
- # Check whether --with-extra-cxxflags was given.
--if test "${with_extra_cxxflags+set}" = set; then :
-+if test ${with_extra_cxxflags+y}
-+then :
-   withval=$with_extra_cxxflags;
- fi
- 
- 
- 
- # Check whether --with-extra-ldflags was given.
--if test "${with_extra_ldflags+set}" = set; then :
-+if test ${with_extra_ldflags+y}
-+then :
-   withval=$with_extra_ldflags;
- fi
- 
- 
- 
- # Check whether --with-extra-asflags was given.
--if test "${with_extra_asflags+set}" = set; then :
-+if test ${with_extra_asflags+y}
-+then :
-   withval=$with_extra_asflags;
- fi
- 
- 
--  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags"
--  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags"
-+  # Define MUSL_LIBC
-+  DEFINE_LIBC=""
-+  if test "x$OPENJDK_TARGET_LIBC" = xmusl; then
-+    DEFINE_LIBC="-DMUSL_LIBC"
-+  fi
-+
-+  CFLAGS_JDK="${CFLAGS_JDK} $with_extra_cflags ${DEFINE_LIBC}"
-+  CXXFLAGS_JDK="${CXXFLAGS_JDK} $with_extra_cxxflags ${DEFINE_LIBC}"
-   LDFLAGS_JDK="${LDFLAGS_JDK} $with_extra_ldflags"
- 
-   # Hotspot needs these set in their legacy form
--  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags"
--  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags"
--  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags"
--  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags"
-+  LEGACY_HOST_CFLAGS="$LEGACY_HOST_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
-+  LEGACY_TARGET_CFLAGS="$LEGACY_TARGET_CFLAGS $with_extra_cflags ${DEFINE_LIBC}"
-+  LEGACY_HOST_CXXFLAGS="$LEGACY_HOST_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
-+  LEGACY_TARGET_CXXFLAGS="$LEGACY_TARGET_CXXFLAGS $with_extra_cxxflags ${DEFINE_LIBC}"
-   LEGACY_HOST_LDFLAGS="$LEGACY_HOST_LDFLAGS $with_extra_ldflags"
-   LEGACY_TARGET_LDFLAGS="$LEGACY_TARGET_LDFLAGS $with_extra_ldflags"
-   LEGACY_HOST_ASFLAGS="$with_extra_asflags"
-@@ -42823,8 +45389,8 @@ fi
-   NO_DELETE_NULL_POINTER_CHECKS_CFLAG="-fno-delete-null-pointer-checks"
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
--$as_echo_n "checking if the C compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
-+printf %s "checking if the C compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
-   supports=yes
- 
-   saved_cflags="$CFLAGS"
-@@ -42840,12 +45406,14 @@ cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_c_try_compile "$LINENO"; then :
-+if ac_fn_c_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -42854,8 +45422,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CFLAGS="$saved_cflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     C_COMP_SUPPORTS="yes"
-   else
-@@ -42863,8 +45431,8 @@ $as_echo "$supports" >&6; }
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
--$as_echo_n "checking if the C++ compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
-+printf %s "checking if the C++ compiler supports \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
-   supports=yes
- 
-   saved_cxxflags="$CXXFLAGS"
-@@ -42879,12 +45447,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -42893,8 +45463,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CXXFLAGS="$saved_cxxflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     CXX_COMP_SUPPORTS="yes"
-   else
-@@ -42902,13 +45472,13 @@ $as_echo "$supports" >&6; }
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
--$as_echo_n "checking if both compilers support \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"" >&5
-+printf %s "checking if both compilers support \"$NO_DELETE_NULL_POINTER_CHECKS_CFLAG -Werror\"... " >&6; }
-   supports=no
-   if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     :
-   else
-@@ -42919,8 +45489,8 @@ $as_echo "$supports" >&6; }
-   NO_LIFETIME_DSE_CFLAG="-fno-lifetime-dse"
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
--$as_echo_n "checking if the C compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
-+printf %s "checking if the C compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
-   supports=yes
- 
-   saved_cflags="$CFLAGS"
-@@ -42935,12 +45505,14 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_c_try_compile "$LINENO"; then :
-+if ac_fn_c_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -42949,8 +45521,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CFLAGS="$saved_cflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     C_COMP_SUPPORTS="yes"
-   else
-@@ -42958,8 +45530,8 @@ $as_echo "$supports" >&6; }
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
--$as_echo_n "checking if the C++ compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
-+printf %s "checking if the C++ compiler supports \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
-   supports=yes
- 
-   saved_cxxflags="$CXXFLAGS"
-@@ -42974,12 +45546,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -42988,8 +45562,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CXXFLAGS="$saved_cxxflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     CXX_COMP_SUPPORTS="yes"
-   else
-@@ -42997,13 +45571,13 @@ $as_echo "$supports" >&6; }
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
--$as_echo_n "checking if both compilers support \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$NO_LIFETIME_DSE_CFLAG -Werror\"" >&5
-+printf %s "checking if both compilers support \"$NO_LIFETIME_DSE_CFLAG -Werror\"... " >&6; }
-   supports=no
-   if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     :
-   else
-@@ -43024,8 +45598,8 @@ $as_echo "$supports" >&6; }
-     # Set USE_FORMAT_OVERFLOW to 1 if it does.
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"-Wformat-overflow -Werror\"" >&5
--$as_echo_n "checking if the C compiler supports \"-Wformat-overflow -Werror\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"-Wformat-overflow -Werror\"" >&5
-+printf %s "checking if the C compiler supports \"-Wformat-overflow -Werror\"... " >&6; }
-   supports=yes
- 
-   saved_cflags="$CFLAGS"
-@@ -43040,12 +45614,14 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_c_try_compile "$LINENO"; then :
-+if ac_fn_c_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -43054,8 +45630,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CFLAGS="$saved_cflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     C_COMP_SUPPORTS="yes"
-   else
-@@ -43063,8 +45639,8 @@ $as_echo "$supports" >&6; }
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"-Wformat-overflow -Werror\"" >&5
--$as_echo_n "checking if the C++ compiler supports \"-Wformat-overflow -Werror\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"-Wformat-overflow -Werror\"" >&5
-+printf %s "checking if the C++ compiler supports \"-Wformat-overflow -Werror\"... " >&6; }
-   supports=yes
- 
-   saved_cxxflags="$CXXFLAGS"
-@@ -43079,12 +45655,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -43093,8 +45671,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CXXFLAGS="$saved_cxxflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     CXX_COMP_SUPPORTS="yes"
-   else
-@@ -43102,13 +45680,13 @@ $as_echo "$supports" >&6; }
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"-Wformat-overflow -Werror\"" >&5
--$as_echo_n "checking if both compilers support \"-Wformat-overflow -Werror\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"-Wformat-overflow -Werror\"" >&5
-+printf %s "checking if both compilers support \"-Wformat-overflow -Werror\"... " >&6; }
-   supports=no
-   if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     USE_FORMAT_OVERFLOW="1"
-   else
-@@ -43129,8 +45707,8 @@ $as_echo "$supports" >&6; }
-     #          -mno-fused-madd -fno-strict-aliasing for GCC < 4.6
-     COMPILER_FP_CONTRACT_OFF_FLAG="-ffp-contract=off"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$COMPILER_FP_CONTRACT_OFF_FLAG -Werror\"" >&5
--$as_echo_n "checking if the C++ compiler supports \"$COMPILER_FP_CONTRACT_OFF_FLAG -Werror\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$COMPILER_FP_CONTRACT_OFF_FLAG -Werror\"" >&5
-+printf %s "checking if the C++ compiler supports \"$COMPILER_FP_CONTRACT_OFF_FLAG -Werror\"... " >&6; }
-   supports=yes
- 
-   saved_cxxflags="$CXXFLAGS"
-@@ -43145,12 +45723,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -43159,8 +45739,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CXXFLAGS="$saved_cxxflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     :
-   else
-@@ -43173,8 +45753,8 @@ $as_echo "$supports" >&6; }
-          test "$OPENJDK_TARGET_CPU_ARCH" = "ppc"; then
-         M_NO_FUSED_ADD_FLAG="-mno-fused-madd"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$M_NO_FUSED_ADD_FLAG -Werror\"" >&5
--$as_echo_n "checking if the C++ compiler supports \"$M_NO_FUSED_ADD_FLAG -Werror\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$M_NO_FUSED_ADD_FLAG -Werror\"" >&5
-+printf %s "checking if the C++ compiler supports \"$M_NO_FUSED_ADD_FLAG -Werror\"... " >&6; }
-   supports=yes
- 
-   saved_cxxflags="$CXXFLAGS"
-@@ -43189,12 +45769,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -43203,8 +45785,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CXXFLAGS="$saved_cxxflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     :
-   else
-@@ -43213,8 +45795,8 @@ $as_echo "$supports" >&6; }
- 
-         NO_STRICT_ALIASING_FLAG="-fno-strict-aliasing"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_STRICT_ALIASING_FLAG -Werror\"" >&5
--$as_echo_n "checking if the C++ compiler supports \"$NO_STRICT_ALIASING_FLAG -Werror\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$NO_STRICT_ALIASING_FLAG -Werror\"" >&5
-+printf %s "checking if the C++ compiler supports \"$NO_STRICT_ALIASING_FLAG -Werror\"... " >&6; }
-   supports=yes
- 
-   saved_cxxflags="$CXXFLAGS"
-@@ -43229,12 +45811,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -43243,8 +45827,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CXXFLAGS="$saved_cxxflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     :
-   else
-@@ -43519,8 +46103,8 @@ $as_echo "$supports" >&6; }
-   esac
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$ZERO_ARCHFLAG\"" >&5
--$as_echo_n "checking if the C compiler supports \"$ZERO_ARCHFLAG\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"$ZERO_ARCHFLAG\"" >&5
-+printf %s "checking if the C compiler supports \"$ZERO_ARCHFLAG\"... " >&6; }
-   supports=yes
- 
-   saved_cflags="$CFLAGS"
-@@ -43535,12 +46119,14 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_c_try_compile "$LINENO"; then :
-+if ac_fn_c_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -43549,8 +46135,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CFLAGS="$saved_cflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     C_COMP_SUPPORTS="yes"
-   else
-@@ -43558,8 +46144,8 @@ $as_echo "$supports" >&6; }
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$ZERO_ARCHFLAG\"" >&5
--$as_echo_n "checking if the C++ compiler supports \"$ZERO_ARCHFLAG\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"$ZERO_ARCHFLAG\"" >&5
-+printf %s "checking if the C++ compiler supports \"$ZERO_ARCHFLAG\"... " >&6; }
-   supports=yes
- 
-   saved_cxxflags="$CXXFLAGS"
-@@ -43574,12 +46160,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -43588,8 +46176,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CXXFLAGS="$saved_cxxflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     CXX_COMP_SUPPORTS="yes"
-   else
-@@ -43597,13 +46185,13 @@ $as_echo "$supports" >&6; }
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$ZERO_ARCHFLAG\"" >&5
--$as_echo_n "checking if both compilers support \"$ZERO_ARCHFLAG\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"$ZERO_ARCHFLAG\"" >&5
-+printf %s "checking if both compilers support \"$ZERO_ARCHFLAG\"... " >&6; }
-   supports=no
-   if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     :
-   else
-@@ -43616,8 +46204,8 @@ $as_echo "$supports" >&6; }
-   # Set COMPILER_SUPPORTS_TARGET_BITS_FLAG to 'true' if it does
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
--$as_echo_n "checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
-+printf %s "checking if the C compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
-   supports=yes
- 
-   saved_cflags="$CFLAGS"
-@@ -43632,12 +46220,14 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_c_try_compile "$LINENO"; then :
-+if ac_fn_c_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -43646,8 +46236,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CFLAGS="$saved_cflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     C_COMP_SUPPORTS="yes"
-   else
-@@ -43655,8 +46245,8 @@ $as_echo "$supports" >&6; }
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
--$as_echo_n "checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
-+printf %s "checking if the C++ compiler supports \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
-   supports=yes
- 
-   saved_cxxflags="$CXXFLAGS"
-@@ -43671,12 +46261,14 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- /* end confdefs.h.  */
- int i;
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
- 
--else
--  supports=no
-+else case e in #(
-+  e) supports=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -43685,8 +46277,8 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
-   CXXFLAGS="$saved_cxxflags"
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     CXX_COMP_SUPPORTS="yes"
-   else
-@@ -43694,13 +46286,13 @@ $as_echo "$supports" >&6; }
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
--$as_echo_n "checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"" >&5
-+printf %s "checking if both compilers support \"${COMPILER_TARGET_BITS_FLAG}${OPENJDK_TARGET_CPU_BITS}\"... " >&6; }
-   supports=no
-   if test "x$C_COMP_SUPPORTS" = "xyes" -a "x$CXX_COMP_SUPPORTS" = "xyes"; then supports=yes; fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
--$as_echo "$supports" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $supports" >&5
-+printf "%s\n" "$supports" >&6; }
-   if test "x$supports" = "xyes" ; then
-     COMPILER_SUPPORTS_TARGET_BITS_FLAG=true
-   else
-@@ -43720,13 +46312,14 @@ $as_echo "$supports" >&6; }
-   # This must be done after the toolchain is setup, since we're looking at objcopy.
-   #
-   # Check whether --enable-debug-symbols was given.
--if test "${enable_debug_symbols+set}" = set; then :
-+if test ${enable_debug_symbols+y}
-+then :
-   enableval=$enable_debug_symbols;
- fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should generate debug symbols" >&5
--$as_echo_n "checking if we should generate debug symbols... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we should generate debug symbols" >&5
-+printf %s "checking if we should generate debug symbols... " >&6; }
- 
-   if test "x$enable_debug_symbols" = "xyes" && test "x$OBJCOPY" = x; then
-     # explicit enabling of enable-debug-symbols and can't find objcopy
-@@ -43750,8 +46343,8 @@ $as_echo_n "checking if we should generate debug symbols... " >&6; }
-     fi
-   fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_DEBUG_SYMBOLS" >&5
--$as_echo "$ENABLE_DEBUG_SYMBOLS" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ENABLE_DEBUG_SYMBOLS" >&5
-+printf "%s\n" "$ENABLE_DEBUG_SYMBOLS" >&6; }
- 
-   # Backwards compatibility. --with-native-debug-symbols is preferred post JDK-8207234,
-   # but if somebody does not specify it via configure, we still want to preserve old
-@@ -43759,17 +46352,19 @@ $as_echo "$ENABLE_DEBUG_SYMBOLS" >&6; }
-   #
-   # ZIP_DEBUGINFO_FILES
-   #
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we should zip debug-info files" >&5
--$as_echo_n "checking if we should zip debug-info files... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if we should zip debug-info files" >&5
-+printf %s "checking if we should zip debug-info files... " >&6; }
-   # Check whether --enable-zip-debug-info was given.
--if test "${enable_zip_debug_info+set}" = set; then :
-+if test ${enable_zip_debug_info+y}
-+then :
-   enableval=$enable_zip_debug_info; enable_zip_debug_info="${enableval}"
--else
--  enable_zip_debug_info="yes"
-+else case e in #(
-+  e) enable_zip_debug_info="yes" ;;
-+esac
- fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${enable_zip_debug_info}" >&5
--$as_echo "${enable_zip_debug_info}" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${enable_zip_debug_info}" >&5
-+printf "%s\n" "${enable_zip_debug_info}" >&6; }
- 
-   if test "x${enable_zip_debug_info}" = "xno"; then
-     ZIP_DEBUGINFO_FILES=false
-@@ -43783,27 +46378,29 @@ $as_echo "${enable_zip_debug_info}" >&6; }
-   # In addition, this must be done after ENABLE_DEBUG_SYMBOLS and ZIP_DEBUGINFO_FILES
-   # checking in order to preserve backwards compatibility post JDK-8207234.
-   #
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking what type of native debug symbols to use (this will override previous settings)" >&5
--$as_echo_n "checking what type of native debug symbols to use (this will override previous settings)... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what type of native debug symbols to use (this will override previous settings)" >&5
-+printf %s "checking what type of native debug symbols to use (this will override previous settings)... " >&6; }
- 
- # Check whether --with-native-debug-symbols was given.
--if test "${with_native_debug_symbols+set}" = set; then :
-+if test ${with_native_debug_symbols+y}
-+then :
-   withval=$with_native_debug_symbols;
- 
--else
--
-+else case e in #(
-+  e)
-         # Default to unset for backwards compatibility
-         with_native_debug_symbols=""
--
-+       ;;
-+esac
- fi
- 
-   NATIVE_DEBUG_SYMBOLS=$with_native_debug_symbols
-   if test "x$NATIVE_DEBUG_SYMBOLS" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: not specified" >&5
--$as_echo "not specified" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not specified" >&5
-+printf "%s\n" "not specified" >&6; }
-   else
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NATIVE_DEBUG_SYMBOLS" >&5
--$as_echo "$NATIVE_DEBUG_SYMBOLS" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NATIVE_DEBUG_SYMBOLS" >&5
-+printf "%s\n" "$NATIVE_DEBUG_SYMBOLS" >&6; }
-   fi
-   # Default is empty
-   DEBUG_BINARIES=
-@@ -43849,8 +46446,8 @@ $as_echo "$NATIVE_DEBUG_SYMBOLS" >&6; }
-   elif test "x$NATIVE_DEBUG_SYMBOLS" != x; then
-     as_fn_error $? "Allowed native debug symbols are: none, internal, external, zipped" "$LINENO" 5
-   else
--    { $as_echo "$as_me:${as_lineno-$LINENO}: --with-native-debug-symbols not specified. Using values from --disable-debug-symbols and --disable-zip-debug-info" >&5
--$as_echo "$as_me: --with-native-debug-symbols not specified. Using values from --disable-debug-symbols and --disable-zip-debug-info" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: --with-native-debug-symbols not specified. Using values from --disable-debug-symbols and --disable-zip-debug-info" >&5
-+printf "%s\n" "$as_me: --with-native-debug-symbols not specified. Using values from --disable-debug-symbols and --disable-zip-debug-info" >&6;}
-   fi
- 
- 
-@@ -43874,8 +46471,8 @@ $as_echo "$as_me: --with-native-debug-symbols not specified. Using values from -
-   # called fixpath.
-   FIXPATH=
-   if test "x$OPENJDK_BUILD_OS" = xwindows; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if fixpath can be created" >&5
--$as_echo_n "checking if fixpath can be created... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if fixpath can be created" >&5
-+printf %s "checking if fixpath can be created... " >&6; }
-     FIXPATH_SRC="$SRC_ROOT/common/src/fixpath.c"
-     FIXPATH_BIN="$OUTPUT_ROOT/fixpath.exe"
-     if test "x$OPENJDK_BUILD_OS_ENV" = xwindows.cygwin; then
-@@ -43900,26 +46497,26 @@ $as_echo_n "checking if fixpath can be created... " >&6; }
-     cd $CURDIR
- 
-     if test ! -x $OUTPUT_ROOT/fixpath.exe; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-       cat $OUTPUT_ROOT/fixpath1.log
-       as_fn_error $? "Could not create $OUTPUT_ROOT/fixpath.exe" "$LINENO" 5
-     fi
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if fixpath.exe works" >&5
--$as_echo_n "checking if fixpath.exe works... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if fixpath.exe works" >&5
-+printf %s "checking if fixpath.exe works... " >&6; }
-     cd $OUTPUT_ROOT
-     $FIXPATH $CC $SRC_ROOT/common/src/fixpath.c -Fe$OUTPUT_ROOT/fixpath2.exe > $OUTPUT_ROOT/fixpath2.log 2>&1
-     cd $CURDIR
-     if test ! -x $OUTPUT_ROOT/fixpath2.exe; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-       cat $OUTPUT_ROOT/fixpath2.log
-       as_fn_error $? "fixpath did not work!" "$LINENO" 5
-     fi
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
-     rm -f $OUTPUT_ROOT/fixpath?.??? $OUTPUT_ROOT/fixpath.obj
-   fi
- 
-@@ -43933,61 +46530,61 @@ $as_echo "yes" >&6; }
-   # OS specific settings that we never will need to probe.
-   #
-   if test "x$OPENJDK_TARGET_OS" = xlinux; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on Linux?" >&5
--$as_echo_n "checking what is not needed on Linux?... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what is not needed on Linux?" >&5
-+printf %s "checking what is not needed on Linux?... " >&6; }
-     PULSE_NOT_NEEDED=yes
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: pulse" >&5
--$as_echo "pulse" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: pulse" >&5
-+printf "%s\n" "pulse" >&6; }
-   fi
- 
-   if test "x$OPENJDK_TARGET_OS" = xsolaris; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on Solaris?" >&5
--$as_echo_n "checking what is not needed on Solaris?... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what is not needed on Solaris?" >&5
-+printf %s "checking what is not needed on Solaris?... " >&6; }
-     ALSA_NOT_NEEDED=yes
-     PULSE_NOT_NEEDED=yes
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa pulse" >&5
--$as_echo "alsa pulse" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: alsa pulse" >&5
-+printf "%s\n" "alsa pulse" >&6; }
-   fi
- 
-   if test "x$OPENJDK_TARGET_OS" = xaix; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on AIX?" >&5
--$as_echo_n "checking what is not needed on AIX?... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what is not needed on AIX?" >&5
-+printf %s "checking what is not needed on AIX?... " >&6; }
-     ALSA_NOT_NEEDED=yes
-     PULSE_NOT_NEEDED=yes
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa pulse" >&5
--$as_echo "alsa pulse" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: alsa pulse" >&5
-+printf "%s\n" "alsa pulse" >&6; }
-   fi
- 
- 
-   if test "x$OPENJDK_TARGET_OS" = xwindows; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on Windows?" >&5
--$as_echo_n "checking what is not needed on Windows?... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what is not needed on Windows?" >&5
-+printf %s "checking what is not needed on Windows?... " >&6; }
-     CUPS_NOT_NEEDED=yes
-     ALSA_NOT_NEEDED=yes
-     PULSE_NOT_NEEDED=yes
-     X11_NOT_NEEDED=yes
-     FONTCONFIG_NOT_NEEDED=yes
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa cups pulse x11" >&5
--$as_echo "alsa cups pulse x11" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: alsa cups pulse x11" >&5
-+printf "%s\n" "alsa cups pulse x11" >&6; }
-   fi
- 
-   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on MacOSX?" >&5
--$as_echo_n "checking what is not needed on MacOSX?... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what is not needed on MacOSX?" >&5
-+printf %s "checking what is not needed on MacOSX?... " >&6; }
-     ALSA_NOT_NEEDED=yes
-     PULSE_NOT_NEEDED=yes
-     X11_NOT_NEEDED=yes
-     FONTCONFIG_NOT_NEEDED=yes
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa pulse x11" >&5
--$as_echo "alsa pulse x11" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: alsa pulse x11" >&5
-+printf "%s\n" "alsa pulse x11" >&6; }
-   fi
- 
-   if test "x$OPENJDK_TARGET_OS" = xbsd; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking what is not needed on bsd?" >&5
--$as_echo_n "checking what is not needed on bsd?... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking what is not needed on bsd?" >&5
-+printf %s "checking what is not needed on bsd?... " >&6; }
-     ALSA_NOT_NEEDED=yes
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: alsa" >&5
--$as_echo "alsa" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: alsa" >&5
-+printf "%s\n" "alsa" >&6; }
-   fi
- 
-   if test "x$OPENJDK" = "xfalse"; then
-@@ -44001,18 +46598,20 @@ $as_echo "alsa" >&6; }
-   # Deprecated and now ignored
- 
-   # Check whether --enable-macosx-runtime-support was given.
--if test "${enable_macosx_runtime_support+set}" = set; then :
-+if test ${enable_macosx_runtime_support+y}
-+then :
-   enableval=$enable_macosx_runtime_support;
- fi
- 
-   if test "x$enable_macosx_runtime_support" != x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --enable-macosx-runtime-support is deprecated and will be ignored." >&5
--$as_echo "$as_me: WARNING: Option --enable-macosx-runtime-support is deprecated and will be ignored." >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Option --enable-macosx-runtime-support is deprecated and will be ignored." >&5
-+printf "%s\n" "$as_me: WARNING: Option --enable-macosx-runtime-support is deprecated and will be ignored." >&2;}
-   fi
- 
- 
- 
- 
-+
-   ###############################################################################
-   #
-   # Check for X Windows
-@@ -44043,28 +46642,58 @@ $as_echo "$as_me: WARNING: Option --enable-macosx-runtime-support is deprecated
-   fi
- 
-   # Now let autoconf do it's magic
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for X" >&5
--$as_echo_n "checking for X... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for X" >&5
-+printf %s "checking for X... " >&6; }
- 
- 
- # Check whether --with-x was given.
--if test "${with_x+set}" = set; then :
-+if test ${with_x+y}
-+then :
-   withval=$with_x;
- fi
- 
--# $have_x is `yes', `no', `disabled', or empty when we do not yet know.
-+# $have_x is 'yes', 'no', 'disabled', or empty when we do not yet know.
- if test "x$with_x" = xno; then
-   # The user explicitly disabled X.
-   have_x=disabled
- else
-   case $x_includes,$x_libraries in #(
-     *\'*) as_fn_error $? "cannot use X directory names containing '" "$LINENO" 5;; #(
--    *,NONE | NONE,*) if ${ac_cv_have_x+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  # One or both of the vars are not set, and there is no cached value.
--ac_x_includes=no ac_x_libraries=no
--rm -f -r conftest.dir
-+    *,NONE | NONE,*) if test ${ac_cv_have_x+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) # One or both of the vars are not set, and there is no cached value.
-+ac_x_includes=no
-+ac_x_libraries=no
-+# Do we need to do anything special at all?
-+ac_save_LIBS=$LIBS
-+LIBS="-lX11 $LIBS"
-+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-+/* end confdefs.h.  */
-+#include <X11/Xlib.h>
-+int
-+main (void)
-+{
-+XrmInitialize ()
-+  ;
-+  return 0;
-+}
-+_ACEOF
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-+  # We can compile and link X programs with no special options.
-+  ac_x_includes=
-+  ac_x_libraries=
-+fi
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-+    conftest$ac_exeext conftest.$ac_ext
-+LIBS="$ac_save_LIBS"
-+# If that didn't work, only try xmkmf and file system searches
-+# for native compilation.
-+if test x"$ac_x_includes" = xno && test "$cross_compiling" = no
-+then :
-+  rm -f -r conftest.dir
- if mkdir conftest.dir; then
-   cd conftest.dir
-   cat >Imakefile <<'_ACEOF'
-@@ -44103,7 +46732,7 @@ _ACEOF
-   rm -f -r conftest.dir
- fi
- 
--# Standard set of common directories for X headers.
-+  # Standard set of common directories for X headers.
- # Check X11 before X11Rn because it is often a symlink to the current release.
- ac_x_header_dirs='
- /usr/X11/include
-@@ -44130,6 +46759,8 @@ ac_x_header_dirs='
- /usr/local/include/X11R5
- /usr/local/include/X11R4
- 
-+/opt/X11/include
-+
- /usr/X386/include
- /usr/x386/include
- /usr/XFree86/include/X11
-@@ -44151,16 +46782,18 @@ if test "$ac_x_includes" = no; then
- /* end confdefs.h.  */
- #include <X11/Xlib.h>
- _ACEOF
--if ac_fn_cxx_try_cpp "$LINENO"; then :
-+if ac_fn_cxx_try_cpp "$LINENO"
-+then :
-   # We can compile using X headers with no special include directory.
- ac_x_includes=
--else
--  for ac_dir in $ac_x_header_dirs; do
-+else case e in #(
-+  e) for ac_dir in $ac_x_header_dirs; do
-   if test -r "$ac_dir/X11/Xlib.h"; then
-     ac_x_includes=$ac_dir
-     break
-   fi
--done
-+done ;;
-+esac
- fi
- rm -f conftest.err conftest.i conftest.$ac_ext
- fi # $ac_x_includes = no
-@@ -44175,20 +46808,21 @@ if test "$ac_x_libraries" = no; then
- /* end confdefs.h.  */
- #include <X11/Xlib.h>
- int
--main ()
-+main (void)
- {
- XrmInitialize ()
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   LIBS=$ac_save_LIBS
- # We can link X programs with no special library path.
- ac_x_libraries=
--else
--  LIBS=$ac_save_LIBS
--for ac_dir in `$as_echo "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g`
-+else case e in #(
-+  e) LIBS=$ac_save_LIBS
-+for ac_dir in `printf "%s\n" "$ac_x_includes $ac_x_header_dirs" | sed s/include/lib/g`
- do
-   # Don't even attempt the hair of trying to link an X program!
-   for ac_extension in a so sl dylib la dll; do
-@@ -44197,21 +46831,25 @@ do
-       break 2
-     fi
-   done
--done
-+done ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
- fi # $ac_x_libraries = no
- 
-+fi
-+# Record the results.
- case $ac_x_includes,$ac_x_libraries in #(
--  no,* | *,no | *\'*)
-+  no,* | *,no | *\'*) :
-     # Didn't find X, or a directory has "'" in its name.
--    ac_cv_have_x="have_x=no";; #(
--  *)
-+    ac_cv_have_x="have_x=no" ;; #(
-+  *) :
-     # Record where we found X for the cache.
-     ac_cv_have_x="have_x=yes\
- 	ac_x_includes='$ac_x_includes'\
--	ac_x_libraries='$ac_x_libraries'"
-+	ac_x_libraries='$ac_x_libraries'" ;;
-+esac ;;
- esac
- fi
- ;; #(
-@@ -44221,8 +46859,8 @@ fi
- fi # $with_x != no
- 
- if test "$have_x" != yes; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5
--$as_echo "$have_x" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $have_x" >&5
-+printf "%s\n" "$have_x" >&6; }
-   no_x=yes
- else
-   # If each of the values was on the command line, it overrides each guess.
-@@ -44232,14 +46870,14 @@ else
-   ac_cv_have_x="have_x=yes\
- 	ac_x_includes='$x_includes'\
- 	ac_x_libraries='$x_libraries'"
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5
--$as_echo "libraries $x_libraries, headers $x_includes" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: libraries $x_libraries, headers $x_includes" >&5
-+printf "%s\n" "libraries $x_libraries, headers $x_includes" >&6; }
- fi
- 
-   if test "$no_x" = yes; then
-   # Not all programs may use this symbol, but it does not hurt to define it.
- 
--$as_echo "#define X_DISPLAY_MISSING 1" >>confdefs.h
-+printf "%s\n" "#define X_DISPLAY_MISSING 1" >>confdefs.h
- 
-   X_CFLAGS= X_PRE_LIBS= X_LIBS= X_EXTRA_LIBS=
- else
-@@ -44252,8 +46890,8 @@ else
-     X_LIBS="$X_LIBS -L$x_libraries"
-     # For Solaris; some versions of Sun CC require a space after -R and
-     # others require no space.  Words are not sufficient . . . .
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -R must be followed by a space" >&5
--$as_echo_n "checking whether -R must be followed by a space... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether -R must be followed by a space" >&5
-+printf %s "checking whether -R must be followed by a space... " >&6; }
-     ac_xsave_LIBS=$LIBS; LIBS="$LIBS -R$x_libraries"
-     ac_xsave_cxx_werror_flag=$ac_cxx_werror_flag
-     ac_cxx_werror_flag=yes
-@@ -44261,42 +46899,46 @@ $as_echo_n "checking whether -R must be followed by a space... " >&6; }
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-        X_LIBS="$X_LIBS -R$x_libraries"
--else
--  LIBS="$ac_xsave_LIBS -R $x_libraries"
-+else case e in #(
-+  e) LIBS="$ac_xsave_LIBS -R $x_libraries"
-        cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
- 	  X_LIBS="$X_LIBS -R $x_libraries"
--else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: neither works" >&5
--$as_echo "neither works" >&6; }
-+else case e in #(
-+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: neither works" >&5
-+printf "%s\n" "neither works" >&6; } ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
--    conftest$ac_exeext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-+    conftest$ac_exeext conftest.$ac_ext ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
-     ac_cxx_werror_flag=$ac_xsave_cxx_werror_flag
-     LIBS=$ac_xsave_LIBS
-@@ -44316,108 +46958,108 @@ rm -f core conftest.err conftest.$ac_objext \
-     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--/* Override any GCC internal prototype to avoid an error.
--   Use char because int might match the return type of a GCC
--   builtin and then its argument prototype would still apply.  */
--#ifdef __cplusplus
--extern "C"
--#endif
--char XOpenDisplay ();
-+namespace conftest {
-+  extern "C" int XOpenDisplay ();
-+}
- int
--main ()
-+main (void)
- {
--return XOpenDisplay ();
-+return conftest::XOpenDisplay ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
--
--else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet" >&5
--$as_echo_n "checking for dnet_ntoa in -ldnet... " >&6; }
--if ${ac_cv_lib_dnet_dnet_ntoa+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_check_lib_save_LIBS=$LIBS
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-+
-+else case e in #(
-+  e) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet" >&5
-+printf %s "checking for dnet_ntoa in -ldnet... " >&6; }
-+if test ${ac_cv_lib_dnet_dnet_ntoa+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_check_lib_save_LIBS=$LIBS
- LIBS="-ldnet  $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--/* Override any GCC internal prototype to avoid an error.
--   Use char because int might match the return type of a GCC
--   builtin and then its argument prototype would still apply.  */
--#ifdef __cplusplus
--extern "C"
--#endif
--char dnet_ntoa ();
-+namespace conftest {
-+  extern "C" int dnet_ntoa ();
-+}
- int
--main ()
-+main (void)
- {
--return dnet_ntoa ();
-+return conftest::dnet_ntoa ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   ac_cv_lib_dnet_dnet_ntoa=yes
--else
--  ac_cv_lib_dnet_dnet_ntoa=no
-+else case e in #(
-+  e) ac_cv_lib_dnet_dnet_ntoa=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
--LIBS=$ac_check_lib_save_LIBS
-+LIBS=$ac_check_lib_save_LIBS ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_dnet_ntoa" >&5
--$as_echo "$ac_cv_lib_dnet_dnet_ntoa" >&6; }
--if test "x$ac_cv_lib_dnet_dnet_ntoa" = xyes; then :
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_dnet_ntoa" >&5
-+printf "%s\n" "$ac_cv_lib_dnet_dnet_ntoa" >&6; }
-+if test "x$ac_cv_lib_dnet_dnet_ntoa" = xyes
-+then :
-   X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet"
- fi
- 
-     if test $ac_cv_lib_dnet_dnet_ntoa = no; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet_stub" >&5
--$as_echo_n "checking for dnet_ntoa in -ldnet_stub... " >&6; }
--if ${ac_cv_lib_dnet_stub_dnet_ntoa+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_check_lib_save_LIBS=$LIBS
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dnet_ntoa in -ldnet_stub" >&5
-+printf %s "checking for dnet_ntoa in -ldnet_stub... " >&6; }
-+if test ${ac_cv_lib_dnet_stub_dnet_ntoa+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_check_lib_save_LIBS=$LIBS
- LIBS="-ldnet_stub  $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--/* Override any GCC internal prototype to avoid an error.
--   Use char because int might match the return type of a GCC
--   builtin and then its argument prototype would still apply.  */
--#ifdef __cplusplus
--extern "C"
--#endif
--char dnet_ntoa ();
-+namespace conftest {
-+  extern "C" int dnet_ntoa ();
-+}
- int
--main ()
-+main (void)
- {
--return dnet_ntoa ();
-+return conftest::dnet_ntoa ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   ac_cv_lib_dnet_stub_dnet_ntoa=yes
--else
--  ac_cv_lib_dnet_stub_dnet_ntoa=no
-+else case e in #(
-+  e) ac_cv_lib_dnet_stub_dnet_ntoa=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
--LIBS=$ac_check_lib_save_LIBS
-+LIBS=$ac_check_lib_save_LIBS ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_stub_dnet_ntoa" >&5
--$as_echo "$ac_cv_lib_dnet_stub_dnet_ntoa" >&6; }
--if test "x$ac_cv_lib_dnet_stub_dnet_ntoa" = xyes; then :
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dnet_stub_dnet_ntoa" >&5
-+printf "%s\n" "$ac_cv_lib_dnet_stub_dnet_ntoa" >&6; }
-+if test "x$ac_cv_lib_dnet_stub_dnet_ntoa" = xyes
-+then :
-   X_EXTRA_LIBS="$X_EXTRA_LIBS -ldnet_stub"
- fi
- 
--    fi
-+    fi ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
-     LIBS="$ac_xsave_LIBS"
- 
-@@ -44430,89 +47072,92 @@ rm -f core conftest.err conftest.$ac_objext \
-     # The functions gethostbyname, getservbyname, and inet_addr are
-     # in -lbsd on LynxOS 3.0.1/i386, according to Lars Hecking.
-     ac_fn_cxx_check_func "$LINENO" "gethostbyname" "ac_cv_func_gethostbyname"
--if test "x$ac_cv_func_gethostbyname" = xyes; then :
-+if test "x$ac_cv_func_gethostbyname" = xyes
-+then :
- 
- fi
- 
-     if test $ac_cv_func_gethostbyname = no; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5
--$as_echo_n "checking for gethostbyname in -lnsl... " >&6; }
--if ${ac_cv_lib_nsl_gethostbyname+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_check_lib_save_LIBS=$LIBS
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lnsl" >&5
-+printf %s "checking for gethostbyname in -lnsl... " >&6; }
-+if test ${ac_cv_lib_nsl_gethostbyname+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_check_lib_save_LIBS=$LIBS
- LIBS="-lnsl  $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--/* Override any GCC internal prototype to avoid an error.
--   Use char because int might match the return type of a GCC
--   builtin and then its argument prototype would still apply.  */
--#ifdef __cplusplus
--extern "C"
--#endif
--char gethostbyname ();
-+namespace conftest {
-+  extern "C" int gethostbyname ();
-+}
- int
--main ()
-+main (void)
- {
--return gethostbyname ();
-+return conftest::gethostbyname ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   ac_cv_lib_nsl_gethostbyname=yes
--else
--  ac_cv_lib_nsl_gethostbyname=no
-+else case e in #(
-+  e) ac_cv_lib_nsl_gethostbyname=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
--LIBS=$ac_check_lib_save_LIBS
-+LIBS=$ac_check_lib_save_LIBS ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5
--$as_echo "$ac_cv_lib_nsl_gethostbyname" >&6; }
--if test "x$ac_cv_lib_nsl_gethostbyname" = xyes; then :
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_nsl_gethostbyname" >&5
-+printf "%s\n" "$ac_cv_lib_nsl_gethostbyname" >&6; }
-+if test "x$ac_cv_lib_nsl_gethostbyname" = xyes
-+then :
-   X_EXTRA_LIBS="$X_EXTRA_LIBS -lnsl"
- fi
- 
-       if test $ac_cv_lib_nsl_gethostbyname = no; then
--	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lbsd" >&5
--$as_echo_n "checking for gethostbyname in -lbsd... " >&6; }
--if ${ac_cv_lib_bsd_gethostbyname+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_check_lib_save_LIBS=$LIBS
-+	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for gethostbyname in -lbsd" >&5
-+printf %s "checking for gethostbyname in -lbsd... " >&6; }
-+if test ${ac_cv_lib_bsd_gethostbyname+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_check_lib_save_LIBS=$LIBS
- LIBS="-lbsd  $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--/* Override any GCC internal prototype to avoid an error.
--   Use char because int might match the return type of a GCC
--   builtin and then its argument prototype would still apply.  */
--#ifdef __cplusplus
--extern "C"
--#endif
--char gethostbyname ();
-+namespace conftest {
-+  extern "C" int gethostbyname ();
-+}
- int
--main ()
-+main (void)
- {
--return gethostbyname ();
-+return conftest::gethostbyname ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   ac_cv_lib_bsd_gethostbyname=yes
--else
--  ac_cv_lib_bsd_gethostbyname=no
-+else case e in #(
-+  e) ac_cv_lib_bsd_gethostbyname=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
--LIBS=$ac_check_lib_save_LIBS
-+LIBS=$ac_check_lib_save_LIBS ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bsd_gethostbyname" >&5
--$as_echo "$ac_cv_lib_bsd_gethostbyname" >&6; }
--if test "x$ac_cv_lib_bsd_gethostbyname" = xyes; then :
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_bsd_gethostbyname" >&5
-+printf "%s\n" "$ac_cv_lib_bsd_gethostbyname" >&6; }
-+if test "x$ac_cv_lib_bsd_gethostbyname" = xyes
-+then :
-   X_EXTRA_LIBS="$X_EXTRA_LIBS -lbsd"
- fi
- 
-@@ -44527,48 +47172,50 @@ fi
-     # must be given before -lnsl if both are needed.  We assume that
-     # if connect needs -lnsl, so does gethostbyname.
-     ac_fn_cxx_check_func "$LINENO" "connect" "ac_cv_func_connect"
--if test "x$ac_cv_func_connect" = xyes; then :
-+if test "x$ac_cv_func_connect" = xyes
-+then :
- 
- fi
- 
-     if test $ac_cv_func_connect = no; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for connect in -lsocket" >&5
--$as_echo_n "checking for connect in -lsocket... " >&6; }
--if ${ac_cv_lib_socket_connect+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_check_lib_save_LIBS=$LIBS
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for connect in -lsocket" >&5
-+printf %s "checking for connect in -lsocket... " >&6; }
-+if test ${ac_cv_lib_socket_connect+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_check_lib_save_LIBS=$LIBS
- LIBS="-lsocket $X_EXTRA_LIBS $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--/* Override any GCC internal prototype to avoid an error.
--   Use char because int might match the return type of a GCC
--   builtin and then its argument prototype would still apply.  */
--#ifdef __cplusplus
--extern "C"
--#endif
--char connect ();
-+namespace conftest {
-+  extern "C" int connect ();
-+}
- int
--main ()
-+main (void)
- {
--return connect ();
-+return conftest::connect ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   ac_cv_lib_socket_connect=yes
--else
--  ac_cv_lib_socket_connect=no
-+else case e in #(
-+  e) ac_cv_lib_socket_connect=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
--LIBS=$ac_check_lib_save_LIBS
-+LIBS=$ac_check_lib_save_LIBS ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_connect" >&5
--$as_echo "$ac_cv_lib_socket_connect" >&6; }
--if test "x$ac_cv_lib_socket_connect" = xyes; then :
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_socket_connect" >&5
-+printf "%s\n" "$ac_cv_lib_socket_connect" >&6; }
-+if test "x$ac_cv_lib_socket_connect" = xyes
-+then :
-   X_EXTRA_LIBS="-lsocket $X_EXTRA_LIBS"
- fi
- 
-@@ -44576,48 +47223,50 @@ fi
- 
-     # Guillermo Gomez says -lposix is necessary on A/UX.
-     ac_fn_cxx_check_func "$LINENO" "remove" "ac_cv_func_remove"
--if test "x$ac_cv_func_remove" = xyes; then :
-+if test "x$ac_cv_func_remove" = xyes
-+then :
- 
- fi
- 
-     if test $ac_cv_func_remove = no; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for remove in -lposix" >&5
--$as_echo_n "checking for remove in -lposix... " >&6; }
--if ${ac_cv_lib_posix_remove+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_check_lib_save_LIBS=$LIBS
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for remove in -lposix" >&5
-+printf %s "checking for remove in -lposix... " >&6; }
-+if test ${ac_cv_lib_posix_remove+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_check_lib_save_LIBS=$LIBS
- LIBS="-lposix  $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--/* Override any GCC internal prototype to avoid an error.
--   Use char because int might match the return type of a GCC
--   builtin and then its argument prototype would still apply.  */
--#ifdef __cplusplus
--extern "C"
--#endif
--char remove ();
-+namespace conftest {
-+  extern "C" int remove ();
-+}
- int
--main ()
-+main (void)
- {
--return remove ();
-+return conftest::remove ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   ac_cv_lib_posix_remove=yes
--else
--  ac_cv_lib_posix_remove=no
-+else case e in #(
-+  e) ac_cv_lib_posix_remove=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
--LIBS=$ac_check_lib_save_LIBS
-+LIBS=$ac_check_lib_save_LIBS ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix_remove" >&5
--$as_echo "$ac_cv_lib_posix_remove" >&6; }
--if test "x$ac_cv_lib_posix_remove" = xyes; then :
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_posix_remove" >&5
-+printf "%s\n" "$ac_cv_lib_posix_remove" >&6; }
-+if test "x$ac_cv_lib_posix_remove" = xyes
-+then :
-   X_EXTRA_LIBS="$X_EXTRA_LIBS -lposix"
- fi
- 
-@@ -44625,48 +47274,50 @@ fi
- 
-     # BSDI BSD/OS 2.1 needs -lipc for XOpenDisplay.
-     ac_fn_cxx_check_func "$LINENO" "shmat" "ac_cv_func_shmat"
--if test "x$ac_cv_func_shmat" = xyes; then :
-+if test "x$ac_cv_func_shmat" = xyes
-+then :
- 
- fi
- 
-     if test $ac_cv_func_shmat = no; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shmat in -lipc" >&5
--$as_echo_n "checking for shmat in -lipc... " >&6; }
--if ${ac_cv_lib_ipc_shmat+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_check_lib_save_LIBS=$LIBS
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for shmat in -lipc" >&5
-+printf %s "checking for shmat in -lipc... " >&6; }
-+if test ${ac_cv_lib_ipc_shmat+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_check_lib_save_LIBS=$LIBS
- LIBS="-lipc  $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--/* Override any GCC internal prototype to avoid an error.
--   Use char because int might match the return type of a GCC
--   builtin and then its argument prototype would still apply.  */
--#ifdef __cplusplus
--extern "C"
--#endif
--char shmat ();
-+namespace conftest {
-+  extern "C" int shmat ();
-+}
- int
--main ()
-+main (void)
- {
--return shmat ();
-+return conftest::shmat ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   ac_cv_lib_ipc_shmat=yes
--else
--  ac_cv_lib_ipc_shmat=no
-+else case e in #(
-+  e) ac_cv_lib_ipc_shmat=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
--LIBS=$ac_check_lib_save_LIBS
-+LIBS=$ac_check_lib_save_LIBS ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ipc_shmat" >&5
--$as_echo "$ac_cv_lib_ipc_shmat" >&6; }
--if test "x$ac_cv_lib_ipc_shmat" = xyes; then :
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ipc_shmat" >&5
-+printf "%s\n" "$ac_cv_lib_ipc_shmat" >&6; }
-+if test "x$ac_cv_lib_ipc_shmat" = xyes
-+then :
-   X_EXTRA_LIBS="$X_EXTRA_LIBS -lipc"
- fi
- 
-@@ -44682,43 +47333,44 @@ fi
-   # These have to be linked with before -lX11, unlike the other
-   # libraries we check for below, so use a different variable.
-   # John Interrante, Karl Berry
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for IceConnectionNumber in -lICE" >&5
--$as_echo_n "checking for IceConnectionNumber in -lICE... " >&6; }
--if ${ac_cv_lib_ICE_IceConnectionNumber+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_check_lib_save_LIBS=$LIBS
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for IceConnectionNumber in -lICE" >&5
-+printf %s "checking for IceConnectionNumber in -lICE... " >&6; }
-+if test ${ac_cv_lib_ICE_IceConnectionNumber+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_check_lib_save_LIBS=$LIBS
- LIBS="-lICE $X_EXTRA_LIBS $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--/* Override any GCC internal prototype to avoid an error.
--   Use char because int might match the return type of a GCC
--   builtin and then its argument prototype would still apply.  */
--#ifdef __cplusplus
--extern "C"
--#endif
--char IceConnectionNumber ();
-+namespace conftest {
-+  extern "C" int IceConnectionNumber ();
-+}
- int
--main ()
-+main (void)
- {
--return IceConnectionNumber ();
-+return conftest::IceConnectionNumber ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   ac_cv_lib_ICE_IceConnectionNumber=yes
--else
--  ac_cv_lib_ICE_IceConnectionNumber=no
-+else case e in #(
-+  e) ac_cv_lib_ICE_IceConnectionNumber=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
--LIBS=$ac_check_lib_save_LIBS
-+LIBS=$ac_check_lib_save_LIBS ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ICE_IceConnectionNumber" >&5
--$as_echo "$ac_cv_lib_ICE_IceConnectionNumber" >&6; }
--if test "x$ac_cv_lib_ICE_IceConnectionNumber" = xyes; then :
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_ICE_IceConnectionNumber" >&5
-+printf "%s\n" "$ac_cv_lib_ICE_IceConnectionNumber" >&6; }
-+if test "x$ac_cv_lib_ICE_IceConnectionNumber" = xyes
-+then :
-   X_PRE_LIBS="$X_PRE_LIBS -lSM -lICE"
- fi
- 
-@@ -44798,27 +47450,28 @@ ac_compiler_gnu=$ac_cv_c_compiler_gnu
-   CFLAGS="$CFLAGS $X_CFLAGS"
- 
-   # Need to include Xlib.h and Xutil.h to avoid "present but cannot be compiled" warnings on Solaris 10
--  for ac_header in X11/extensions/shape.h X11/extensions/Xrender.h X11/extensions/XTest.h X11/Intrinsic.h
-+         for ac_header in X11/extensions/shape.h X11/extensions/Xrender.h X11/extensions/XTest.h X11/Intrinsic.h
- do :
--  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
-+  as_ac_Header=`printf "%s\n" "ac_cv_header_$ac_header" | sed "$as_sed_sh"`
- ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "
-         # include <X11/Xlib.h>
-         # include <X11/Xutil.h>
- 
- 
- "
--if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
-+if eval test \"x\$"$as_ac_Header"\" = x"yes"
-+then :
-   cat >>confdefs.h <<_ACEOF
--#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
-+#define `printf "%s\n" "HAVE_$ac_header" | sed "$as_sed_cpp"` 1
- _ACEOF
-  X11_A_OK=yes
--else
--  X11_A_OK=no; break
-+else case e in #(
-+  e) X11_A_OK=no; break ;;
-+esac
- fi
- 
- done
- 
--
-   CFLAGS="$OLD_CFLAGS"
-   ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
-@@ -44872,21 +47525,23 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
-   #
- 
- # Check whether --with-cups was given.
--if test "${with_cups+set}" = set; then :
-+if test ${with_cups+y}
-+then :
-   withval=$with_cups;
- fi
- 
- 
- # Check whether --with-cups-include was given.
--if test "${with_cups_include+set}" = set; then :
-+if test ${with_cups_include+y}
-+then :
-   withval=$with_cups_include;
- fi
- 
- 
-   if test "x$CUPS_NOT_NEEDED" = xyes; then
-     if test "x${with_cups}" != x || test "x${with_cups_include}" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cups not used, so --with-cups is ignored" >&5
--$as_echo "$as_me: WARNING: cups not used, so --with-cups is ignored" >&2;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cups not used, so --with-cups is ignored" >&5
-+printf "%s\n" "$as_me: WARNING: cups not used, so --with-cups is ignored" >&2;}
-     fi
-     CUPS_CFLAGS=
-   else
-@@ -44926,8 +47581,8 @@ $as_echo "$as_me: WARNING: cups not used, so --with-cups is ignored" >&2;}
-       resource=${builddep_cups}
-     fi
-     if test "x$resource" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for cups" >&5
--$as_echo "$as_me: Using builddeps $resource for cups" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for cups" >&5
-+printf "%s\n" "$as_me: Using builddeps $resource for cups" >&6;}
-       # If the resource in the builddeps.conf file is an existing directory,
-       # for example /java/linux/cups
-       if test -d ${resource}; then
-@@ -44947,8 +47602,8 @@ $as_echo "$as_me: Using builddeps $resource for cups" >&6;}
-   extension=${filename#*.}
-   installdir=$with_builddeps_dir/$filebase
-   if test ! -f $installdir/$filename.unpacked; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency cups from $with_builddeps_server/$resource and installing into $installdir" >&5
--$as_echo "$as_me: Downloading build dependency cups from $with_builddeps_server/$resource and installing into $installdir" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Downloading build dependency cups from $with_builddeps_server/$resource and installing into $installdir" >&5
-+printf "%s\n" "$as_me: Downloading build dependency cups from $with_builddeps_server/$resource and installing into $installdir" >&6;}
-     if test ! -d $installdir; then
-       mkdir -p $installdir
-     fi
-@@ -45051,13 +47706,14 @@ $as_echo "$as_me: Downloading build dependency cups from $with_builddeps_server/
-     fi
-     if test "x$CUPS_FOUND" = xno; then
-       # Are the cups headers installed in the default /usr/include location?
--      for ac_header in cups/cups.h cups/ppd.h
-+             for ac_header in cups/cups.h cups/ppd.h
- do :
--  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
--ac_fn_cxx_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
--if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
-+  as_ac_Header=`printf "%s\n" "ac_cv_header_$ac_header" | sed "$as_sed_sh"`
-+ac_fn_cxx_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
-+if eval test \"x\$"$as_ac_Header"\" = x"yes"
-+then :
-   cat >>confdefs.h <<_ACEOF
--#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
-+#define `printf "%s\n" "HAVE_$ac_header" | sed "$as_sed_cpp"` 1
- _ACEOF
- 
-             CUPS_FOUND=yes
-@@ -45068,13 +47724,12 @@ _ACEOF
- fi
- 
- done
--
-     fi
-     if test "x$CUPS_FOUND" = xno; then
-       # Getting nervous now? Lets poke around for standard Solaris third-party
-       # package installation locations.
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cups headers" >&5
--$as_echo_n "checking for cups headers... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for cups headers" >&5
-+printf %s "checking for cups headers... " >&6; }
-       if test -s $SYSROOT/opt/sfw/cups/include/cups/cups.h; then
-         # An SFW package seems to be installed!
-         CUPS_FOUND=yes
-@@ -45084,8 +47739,8 @@ $as_echo_n "checking for cups headers... " >&6; }
-         CUPS_FOUND=yes
-         CUPS_CFLAGS="-I$SYSROOT/opt/csw/include"
-       fi
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CUPS_FOUND" >&5
--$as_echo "$CUPS_FOUND" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CUPS_FOUND" >&5
-+printf "%s\n" "$CUPS_FOUND" >&6; }
-     fi
-     if test "x$CUPS_FOUND" = xno; then
- 
-@@ -45128,19 +47783,22 @@ $as_echo "$CUPS_FOUND" >&6; }
- 
- 
- # Check whether --with-freetype was given.
--if test "${with_freetype+set}" = set; then :
-+if test ${with_freetype+y}
-+then :
-   withval=$with_freetype;
- fi
- 
- 
- # Check whether --with-freetype-include was given.
--if test "${with_freetype_include+set}" = set; then :
-+if test ${with_freetype_include+y}
-+then :
-   withval=$with_freetype_include;
- fi
- 
- 
- # Check whether --with-freetype-lib was given.
--if test "${with_freetype_lib+set}" = set; then :
-+if test ${with_freetype_lib+y}
-+then :
-   withval=$with_freetype_lib;
- fi
- 
-@@ -45221,29 +47879,29 @@ fi
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     # Include file found, let's continue the sanity check.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
--$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
-+printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-     FOUND_FREETYPE=yes
- 
-     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
-     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
--$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
-+printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-       FOUND_FREETYPE=no
-     fi
-   fi
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
--$as_echo_n "checking for freetype includes... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
--$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
-+printf %s "checking for freetype includes... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
-+printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
-     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
--$as_echo_n "checking for freetype libraries... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
--$as_echo "$FREETYPE_LIB_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
-+printf %s "checking for freetype libraries... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
-+printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
-   fi
- 
-       if test "x$FOUND_FREETYPE" != "xyes" ; then
-@@ -45261,17 +47919,17 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
-           if test "x$PKG_CONFIG" != "x" ; then
- 
- pkg_failed=no
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for FREETYPE" >&5
--$as_echo_n "checking for FREETYPE... " >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for FREETYPE" >&5
-+printf %s "checking for FREETYPE... " >&6; }
- 
- if test -n "$FREETYPE_CFLAGS"; then
-     pkg_cv_FREETYPE_CFLAGS="$FREETYPE_CFLAGS"
-  elif test -n "$PKG_CONFIG"; then
-     if test -n "$PKG_CONFIG" && \
--    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5
-+    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5
-   ($PKG_CONFIG --exists --print-errors "freetype2") 2>&5
-   ac_status=$?
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; }; then
-   pkg_cv_FREETYPE_CFLAGS=`$PKG_CONFIG --cflags "freetype2" 2>/dev/null`
- else
-@@ -45284,10 +47942,10 @@ if test -n "$FREETYPE_LIBS"; then
-     pkg_cv_FREETYPE_LIBS="$FREETYPE_LIBS"
-  elif test -n "$PKG_CONFIG"; then
-     if test -n "$PKG_CONFIG" && \
--    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5
-+    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"freetype2\""; } >&5
-   ($PKG_CONFIG --exists --print-errors "freetype2") 2>&5
-   ac_status=$?
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; }; then
-   pkg_cv_FREETYPE_LIBS=`$PKG_CONFIG --libs "freetype2" 2>/dev/null`
- else
-@@ -45314,23 +47972,23 @@ fi
- 	# Put the nasty error message in config.log where it belongs
- 	echo "$FREETYPE_PKG_ERRORS" >&5
- 
--	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-                 FOUND_FREETYPE=no
- elif test $pkg_failed = untried; then
- 	FOUND_FREETYPE=no
- else
- 	FREETYPE_CFLAGS=$pkg_cv_FREETYPE_CFLAGS
- 	FREETYPE_LIBS=$pkg_cv_FREETYPE_LIBS
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
- 	FOUND_FREETYPE=yes
- fi
-             if test "x$FOUND_FREETYPE" = "xyes" ; then
--              { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype" >&5
--$as_echo_n "checking for freetype... " >&6; }
--              { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes (using pkg-config)" >&5
--$as_echo "yes (using pkg-config)" >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype" >&5
-+printf %s "checking for freetype... " >&6; }
-+              { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes (using pkg-config)" >&5
-+printf "%s\n" "yes (using pkg-config)" >&6; }
-             fi
-           fi
-         fi
-@@ -45360,29 +48018,29 @@ $as_echo "yes (using pkg-config)" >&6; }
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     # Include file found, let's continue the sanity check.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
--$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
-+printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-     FOUND_FREETYPE=yes
- 
-     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
-     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
--$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
-+printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-       FOUND_FREETYPE=no
-     fi
-   fi
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
--$as_echo_n "checking for freetype includes... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
--$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
-+printf %s "checking for freetype includes... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
-+printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
-     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
--$as_echo_n "checking for freetype libraries... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
--$as_echo "$FREETYPE_LIB_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
-+printf %s "checking for freetype libraries... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
-+printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
-   fi
- 
-           if test "x$FOUND_FREETYPE" != "xyes" ; then
-@@ -45406,29 +48064,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     # Include file found, let's continue the sanity check.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
--$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
-+printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-     FOUND_FREETYPE=yes
- 
-     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
-     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
--$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
-+printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-       FOUND_FREETYPE=no
-     fi
-   fi
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
--$as_echo_n "checking for freetype includes... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
--$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
-+printf %s "checking for freetype includes... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
-+printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
-     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
--$as_echo_n "checking for freetype libraries... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
--$as_echo "$FREETYPE_LIB_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
-+printf %s "checking for freetype libraries... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
-+printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
-   fi
- 
-           fi
-@@ -45453,29 +48111,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     # Include file found, let's continue the sanity check.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
--$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
-+printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-     FOUND_FREETYPE=yes
- 
-     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
-     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
--$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
-+printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-       FOUND_FREETYPE=no
-     fi
-   fi
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
--$as_echo_n "checking for freetype includes... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
--$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
-+printf %s "checking for freetype includes... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
-+printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
-     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
--$as_echo_n "checking for freetype libraries... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
--$as_echo "$FREETYPE_LIB_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
-+printf %s "checking for freetype libraries... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
-+printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
-   fi
- 
-           if test "x$FOUND_FREETYPE" != "xyes" ; then
-@@ -45499,29 +48157,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     # Include file found, let's continue the sanity check.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
--$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
-+printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-     FOUND_FREETYPE=yes
- 
-     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
-     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
--$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
-+printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-       FOUND_FREETYPE=no
-     fi
-   fi
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
--$as_echo_n "checking for freetype includes... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
--$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
-+printf %s "checking for freetype includes... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
-+printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
-     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
--$as_echo_n "checking for freetype libraries... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
--$as_echo "$FREETYPE_LIB_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
-+printf %s "checking for freetype libraries... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
-+printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
-   fi
- 
-           fi
-@@ -45548,29 +48206,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     # Include file found, let's continue the sanity check.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
--$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
-+printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-     FOUND_FREETYPE=yes
- 
-     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
-     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
--$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
-+printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-       FOUND_FREETYPE=no
-     fi
-   fi
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
--$as_echo_n "checking for freetype includes... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
--$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
-+printf %s "checking for freetype includes... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
-+printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
-     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
--$as_echo_n "checking for freetype libraries... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
--$as_echo "$FREETYPE_LIB_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
-+printf %s "checking for freetype libraries... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
-+printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
-   fi
- 
-         fi
-@@ -45596,29 +48254,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     # Include file found, let's continue the sanity check.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
--$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
-+printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-     FOUND_FREETYPE=yes
- 
-     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
-     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
--$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
-+printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-       FOUND_FREETYPE=no
-     fi
-   fi
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
--$as_echo_n "checking for freetype includes... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
--$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
-+printf %s "checking for freetype includes... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
-+printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
-     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
--$as_echo_n "checking for freetype libraries... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
--$as_echo "$FREETYPE_LIB_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
-+printf %s "checking for freetype libraries... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
-+printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
-   fi
- 
-         fi
-@@ -45644,29 +48302,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     # Include file found, let's continue the sanity check.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
--$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
-+printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-     FOUND_FREETYPE=yes
- 
-     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
-     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
--$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
-+printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-       FOUND_FREETYPE=no
-     fi
-   fi
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
--$as_echo_n "checking for freetype includes... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
--$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
-+printf %s "checking for freetype includes... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
-+printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
-     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
--$as_echo_n "checking for freetype libraries... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
--$as_echo "$FREETYPE_LIB_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
-+printf %s "checking for freetype libraries... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
-+printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
-   fi
- 
-         fi
-@@ -45693,29 +48351,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     # Include file found, let's continue the sanity check.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
--$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
-+printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-     FOUND_FREETYPE=yes
- 
-     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
-     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
--$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
-+printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-       FOUND_FREETYPE=no
-     fi
-   fi
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
--$as_echo_n "checking for freetype includes... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
--$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
-+printf %s "checking for freetype includes... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
-+printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
-     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
--$as_echo_n "checking for freetype libraries... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
--$as_echo "$FREETYPE_LIB_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
-+printf %s "checking for freetype libraries... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
-+printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
-   fi
- 
-         fi
-@@ -45742,29 +48400,29 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     # Include file found, let's continue the sanity check.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
--$as_echo "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&5
-+printf "%s\n" "$as_me: Found freetype include files at $POTENTIAL_FREETYPE_INCLUDE_PATH using $METHOD" >&6;}
-     FOUND_FREETYPE=yes
- 
-     FREETYPE_LIB_NAME="${LIBRARY_PREFIX}${FREETYPE_BASE_NAME}${SHARED_LIBRARY_SUFFIX}"
-     if ! test -s "$POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
--$as_echo "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&5
-+printf "%s\n" "$as_me: Could not find $POTENTIAL_FREETYPE_LIB_PATH/$FREETYPE_LIB_NAME. Ignoring location." >&6;}
-       FOUND_FREETYPE=no
-     fi
-   fi
- 
-   if test "x$FOUND_FREETYPE" = "xyes"; then
-     FREETYPE_INCLUDE_PATH="$POTENTIAL_FREETYPE_INCLUDE_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
--$as_echo_n "checking for freetype includes... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
--$as_echo "$FREETYPE_INCLUDE_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype includes" >&5
-+printf %s "checking for freetype includes... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_INCLUDE_PATH" >&5
-+printf "%s\n" "$FREETYPE_INCLUDE_PATH" >&6; }
-     FREETYPE_LIB_PATH="$POTENTIAL_FREETYPE_LIB_PATH"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
--$as_echo_n "checking for freetype libraries... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
--$as_echo "$FREETYPE_LIB_PATH" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for freetype libraries" >&5
-+printf %s "checking for freetype libraries... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FREETYPE_LIB_PATH" >&5
-+printf "%s\n" "$FREETYPE_LIB_PATH" >&6; }
-   fi
- 
-         fi
-@@ -45819,8 +48477,8 @@ $as_echo "$FREETYPE_LIB_PATH" >&6; }
-     fi
-   fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: Using freetype: $FREETYPE_TO_USE" >&5
--$as_echo "Using freetype: $FREETYPE_TO_USE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: Using freetype: $FREETYPE_TO_USE" >&5
-+printf "%s\n" "Using freetype: $FREETYPE_TO_USE" >&6; }
- 
- 
- 
-@@ -45834,27 +48492,30 @@ $as_echo "Using freetype: $FREETYPE_TO_USE" >&6; }
-   #
- 
- # Check whether --with-alsa was given.
--if test "${with_alsa+set}" = set; then :
-+if test ${with_alsa+y}
-+then :
-   withval=$with_alsa;
- fi
- 
- 
- # Check whether --with-alsa-include was given.
--if test "${with_alsa_include+set}" = set; then :
-+if test ${with_alsa_include+y}
-+then :
-   withval=$with_alsa_include;
- fi
- 
- 
- # Check whether --with-alsa-lib was given.
--if test "${with_alsa_lib+set}" = set; then :
-+if test ${with_alsa_lib+y}
-+then :
-   withval=$with_alsa_lib;
- fi
- 
- 
-   if test "x$ALSA_NOT_NEEDED" = xyes; then
-     if test "x${with_alsa}" != x || test "x${with_alsa_include}" != x || test "x${with_alsa_lib}" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: alsa not used, so --with-alsa is ignored" >&5
--$as_echo "$as_me: WARNING: alsa not used, so --with-alsa is ignored" >&2;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: alsa not used, so --with-alsa is ignored" >&5
-+printf "%s\n" "$as_me: WARNING: alsa not used, so --with-alsa is ignored" >&2;}
-     fi
-     ALSA_CFLAGS=
-     ALSA_LIBS=
-@@ -45900,8 +48561,8 @@ $as_echo "$as_me: WARNING: alsa not used, so --with-alsa is ignored" >&2;}
-       resource=${builddep_alsa}
-     fi
-     if test "x$resource" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for alsa" >&5
--$as_echo "$as_me: Using builddeps $resource for alsa" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Using builddeps $resource for alsa" >&5
-+printf "%s\n" "$as_me: Using builddeps $resource for alsa" >&6;}
-       # If the resource in the builddeps.conf file is an existing directory,
-       # for example /java/linux/cups
-       if test -d ${resource}; then
-@@ -45921,8 +48582,8 @@ $as_echo "$as_me: Using builddeps $resource for alsa" >&6;}
-   extension=${filename#*.}
-   installdir=$with_builddeps_dir/$filebase
-   if test ! -f $installdir/$filename.unpacked; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Downloading build dependency alsa from $with_builddeps_server/$resource and installing into $installdir" >&5
--$as_echo "$as_me: Downloading build dependency alsa from $with_builddeps_server/$resource and installing into $installdir" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Downloading build dependency alsa from $with_builddeps_server/$resource and installing into $installdir" >&5
-+printf "%s\n" "$as_me: Downloading build dependency alsa from $with_builddeps_server/$resource and installing into $installdir" >&6;}
-     if test ! -d $installdir; then
-       mkdir -p $installdir
-     fi
-@@ -46030,17 +48691,17 @@ $as_echo "$as_me: Downloading build dependency alsa from $with_builddeps_server/
-       if test "x$ALSA_FOUND" = xno; then
- 
- pkg_failed=no
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ALSA" >&5
--$as_echo_n "checking for ALSA... " >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for ALSA" >&5
-+printf %s "checking for ALSA... " >&6; }
- 
- if test -n "$ALSA_CFLAGS"; then
-     pkg_cv_ALSA_CFLAGS="$ALSA_CFLAGS"
-  elif test -n "$PKG_CONFIG"; then
-     if test -n "$PKG_CONFIG" && \
--    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5
-+    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5
-   ($PKG_CONFIG --exists --print-errors "alsa") 2>&5
-   ac_status=$?
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; }; then
-   pkg_cv_ALSA_CFLAGS=`$PKG_CONFIG --cflags "alsa" 2>/dev/null`
- else
-@@ -46053,10 +48714,10 @@ if test -n "$ALSA_LIBS"; then
-     pkg_cv_ALSA_LIBS="$ALSA_LIBS"
-  elif test -n "$PKG_CONFIG"; then
-     if test -n "$PKG_CONFIG" && \
--    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5
-+    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"alsa\""; } >&5
-   ($PKG_CONFIG --exists --print-errors "alsa") 2>&5
-   ac_status=$?
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; }; then
-   pkg_cv_ALSA_LIBS=`$PKG_CONFIG --libs "alsa" 2>/dev/null`
- else
-@@ -46083,40 +48744,39 @@ fi
- 	# Put the nasty error message in config.log where it belongs
- 	echo "$ALSA_PKG_ERRORS" >&5
- 
--	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+	{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-                 ALSA_FOUND=no
- elif test $pkg_failed = untried; then
- 	ALSA_FOUND=no
- else
- 	ALSA_CFLAGS=$pkg_cv_ALSA_CFLAGS
- 	ALSA_LIBS=$pkg_cv_ALSA_LIBS
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
- 	ALSA_FOUND=yes
- fi
-       fi
-     fi
-     if test "x$ALSA_FOUND" = xno; then
--      for ac_header in alsa/asoundlib.h
-+             for ac_header in alsa/asoundlib.h
- do :
--  ac_fn_cxx_check_header_mongrel "$LINENO" "alsa/asoundlib.h" "ac_cv_header_alsa_asoundlib_h" "$ac_includes_default"
--if test "x$ac_cv_header_alsa_asoundlib_h" = xyes; then :
--  cat >>confdefs.h <<_ACEOF
--#define HAVE_ALSA_ASOUNDLIB_H 1
--_ACEOF
-+  ac_fn_cxx_check_header_compile "$LINENO" "alsa/asoundlib.h" "ac_cv_header_alsa_asoundlib_h" "$ac_includes_default"
-+if test "x$ac_cv_header_alsa_asoundlib_h" = xyes
-+then :
-+  printf "%s\n" "#define HAVE_ALSA_ASOUNDLIB_H 1" >>confdefs.h
- 
-             ALSA_FOUND=yes
-             ALSA_CFLAGS=-Iignoreme
-             ALSA_LIBS=-lasound
-             DEFAULT_ALSA=yes
- 
--else
--  ALSA_FOUND=no
-+else case e in #(
-+  e) ALSA_FOUND=no ;;
-+esac
- fi
- 
- done
--
-     fi
-     if test "x$ALSA_FOUND" = xno; then
- 
-@@ -46159,13 +48819,15 @@ done
- 
- 
- # Check whether --with-fontconfig was given.
--if test "${with_fontconfig+set}" = set; then :
-+if test ${with_fontconfig+y}
-+then :
-   withval=$with_fontconfig;
- fi
- 
- 
- # Check whether --with-fontconfig-include was given.
--if test "${with_fontconfig_include+set}" = set; then :
-+if test ${with_fontconfig_include+y}
-+then :
-   withval=$with_fontconfig_include;
- fi
- 
-@@ -46173,8 +48835,8 @@ fi
-   if test "x$FONTCONFIG_NOT_NEEDED" = xyes; then
-     if (test "x${with_fontconfig}" != x && test "x${with_fontconfig}" != xno) || \
-         (test "x${with_fontconfig_include}" != x && test "x${with_fontconfig_include}" != xno); then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: fontconfig not used, so --with-fontconfig[-*] is ignored" >&5
--$as_echo "$as_me: WARNING: fontconfig not used, so --with-fontconfig[-*] is ignored" >&2;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: fontconfig not used, so --with-fontconfig[-*] is ignored" >&5
-+printf "%s\n" "$as_me: WARNING: fontconfig not used, so --with-fontconfig[-*] is ignored" >&2;}
-     fi
-     FONTCONFIG_CFLAGS=
-   else
-@@ -46185,38 +48847,37 @@ $as_echo "$as_me: WARNING: fontconfig not used, so --with-fontconfig[-*] is igno
-     fi
- 
-     if test "x${with_fontconfig}" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fontconfig headers" >&5
--$as_echo_n "checking for fontconfig headers... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fontconfig headers" >&5
-+printf %s "checking for fontconfig headers... " >&6; }
-       if test -s "${with_fontconfig}/include/fontconfig/fontconfig.h"; then
-         FONTCONFIG_CFLAGS="-I${with_fontconfig}/include"
-         FONTCONFIG_FOUND=yes
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FONTCONFIG_FOUND" >&5
--$as_echo "$FONTCONFIG_FOUND" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FONTCONFIG_FOUND" >&5
-+printf "%s\n" "$FONTCONFIG_FOUND" >&6; }
-       else
-         as_fn_error $? "Can't find 'include/fontconfig/fontconfig.h' under ${with_fontconfig} given with the --with-fontconfig option." "$LINENO" 5
-       fi
-     fi
-     if test "x${with_fontconfig_include}" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for fontconfig headers" >&5
--$as_echo_n "checking for fontconfig headers... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for fontconfig headers" >&5
-+printf %s "checking for fontconfig headers... " >&6; }
-       if test -s "${with_fontconfig_include}/fontconfig/fontconfig.h"; then
-         FONTCONFIG_CFLAGS="-I${with_fontconfig_include}"
-         FONTCONFIG_FOUND=yes
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $FONTCONFIG_FOUND" >&5
--$as_echo "$FONTCONFIG_FOUND" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $FONTCONFIG_FOUND" >&5
-+printf "%s\n" "$FONTCONFIG_FOUND" >&6; }
-       else
-         as_fn_error $? "Can't find 'fontconfig/fontconfig.h' under ${with_fontconfig_include} given with the --with-fontconfig-include option." "$LINENO" 5
-       fi
-     fi
-     if test "x$FONTCONFIG_FOUND" = xno; then
-       # Are the fontconfig headers installed in the default /usr/include location?
--      for ac_header in fontconfig/fontconfig.h
-+             for ac_header in fontconfig/fontconfig.h
- do :
--  ac_fn_cxx_check_header_mongrel "$LINENO" "fontconfig/fontconfig.h" "ac_cv_header_fontconfig_fontconfig_h" "$ac_includes_default"
--if test "x$ac_cv_header_fontconfig_fontconfig_h" = xyes; then :
--  cat >>confdefs.h <<_ACEOF
--#define HAVE_FONTCONFIG_FONTCONFIG_H 1
--_ACEOF
-+  ac_fn_cxx_check_header_compile "$LINENO" "fontconfig/fontconfig.h" "ac_cv_header_fontconfig_fontconfig_h" "$ac_includes_default"
-+if test "x$ac_cv_header_fontconfig_fontconfig_h" = xyes
-+then :
-+  printf "%s\n" "#define HAVE_FONTCONFIG_FONTCONFIG_H 1" >>confdefs.h
- 
-           FONTCONFIG_FOUND=yes
-           FONTCONFIG_CFLAGS=
-@@ -46225,7 +48886,6 @@ _ACEOF
- fi
- 
- done
--
-     fi
-     if test "x$FONTCONFIG_FOUND" = xno; then
- 
-@@ -46272,48 +48932,54 @@ done
-   #
- 
-   USE_EXTERNAL_LIBJPEG=true
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -ljpeg" >&5
--$as_echo_n "checking for main in -ljpeg... " >&6; }
--if ${ac_cv_lib_jpeg_main+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_check_lib_save_LIBS=$LIBS
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for main in -ljpeg" >&5
-+printf %s "checking for main in -ljpeg... " >&6; }
-+if test ${ac_cv_lib_jpeg_main+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_check_lib_save_LIBS=$LIBS
- LIBS="-ljpeg  $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--
-+namespace conftest {
-+  extern "C" int main ();
-+}
- int
--main ()
-+main (void)
- {
--return main ();
-+return conftest::main ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   ac_cv_lib_jpeg_main=yes
--else
--  ac_cv_lib_jpeg_main=no
-+else case e in #(
-+  e) ac_cv_lib_jpeg_main=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
--LIBS=$ac_check_lib_save_LIBS
-+LIBS=$ac_check_lib_save_LIBS ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_jpeg_main" >&5
--$as_echo "$ac_cv_lib_jpeg_main" >&6; }
--if test "x$ac_cv_lib_jpeg_main" = xyes; then :
--  cat >>confdefs.h <<_ACEOF
--#define HAVE_LIBJPEG 1
--_ACEOF
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_jpeg_main" >&5
-+printf "%s\n" "$ac_cv_lib_jpeg_main" >&6; }
-+if test "x$ac_cv_lib_jpeg_main" = xyes
-+then :
-+  printf "%s\n" "#define HAVE_LIBJPEG 1" >>confdefs.h
- 
-   LIBS="-ljpeg $LIBS"
- 
--else
--   USE_EXTERNAL_LIBJPEG=false
--      { $as_echo "$as_me:${as_lineno-$LINENO}: Will use jpeg decoder bundled with the OpenJDK source" >&5
--$as_echo "$as_me: Will use jpeg decoder bundled with the OpenJDK source" >&6;}
--
-+else case e in #(
-+  e)  USE_EXTERNAL_LIBJPEG=false
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use jpeg decoder bundled with the OpenJDK source" >&5
-+printf "%s\n" "$as_me: Will use jpeg decoder bundled with the OpenJDK source" >&6;}
-+   ;;
-+esac
- fi
- 
- 
-@@ -46325,14 +48991,15 @@ fi
- 
- 
- # Check whether --with-giflib was given.
--if test "${with_giflib+set}" = set; then :
-+if test ${with_giflib+y}
-+then :
-   withval=$with_giflib;
- fi
- 
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for which giflib to use" >&5
--$as_echo_n "checking for which giflib to use... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for which giflib to use" >&5
-+printf %s "checking for which giflib to use... " >&6; }
- 
-   # default is bundled
-   DEFAULT_GIFLIB=bundled
-@@ -46344,65 +49011,66 @@ $as_echo_n "checking for which giflib to use... " >&6; }
-     with_giflib=${DEFAULT_GIFLIB}
-   fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${with_giflib}" >&5
--$as_echo "${with_giflib}" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ${with_giflib}" >&5
-+printf "%s\n" "${with_giflib}" >&6; }
- 
-   if test "x${with_giflib}" = "xbundled"; then
-     USE_EXTERNAL_LIBGIF=false
-   elif test "x${with_giflib}" = "xsystem"; then
--    ac_fn_cxx_check_header_mongrel "$LINENO" "gif_lib.h" "ac_cv_header_gif_lib_h" "$ac_includes_default"
--if test "x$ac_cv_header_gif_lib_h" = xyes; then :
-+    ac_fn_cxx_check_header_compile "$LINENO" "gif_lib.h" "ac_cv_header_gif_lib_h" "$ac_includes_default"
-+if test "x$ac_cv_header_gif_lib_h" = xyes
-+then :
- 
--else
--   as_fn_error $? "--with-giflib=system specified, but gif_lib.h not found!" "$LINENO" 5
-+else case e in #(
-+  e)  as_fn_error $? "--with-giflib=system specified, but gif_lib.h not found!" "$LINENO" 5 ;;
-+esac
- fi
- 
--
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for DGifGetCode in -lgif" >&5
--$as_echo_n "checking for DGifGetCode in -lgif... " >&6; }
--if ${ac_cv_lib_gif_DGifGetCode+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_check_lib_save_LIBS=$LIBS
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for DGifGetCode in -lgif" >&5
-+printf %s "checking for DGifGetCode in -lgif... " >&6; }
-+if test ${ac_cv_lib_gif_DGifGetCode+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_check_lib_save_LIBS=$LIBS
- LIBS="-lgif  $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--/* Override any GCC internal prototype to avoid an error.
--   Use char because int might match the return type of a GCC
--   builtin and then its argument prototype would still apply.  */
--#ifdef __cplusplus
--extern "C"
--#endif
--char DGifGetCode ();
-+namespace conftest {
-+  extern "C" int DGifGetCode ();
-+}
- int
--main ()
-+main (void)
- {
--return DGifGetCode ();
-+return conftest::DGifGetCode ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   ac_cv_lib_gif_DGifGetCode=yes
--else
--  ac_cv_lib_gif_DGifGetCode=no
-+else case e in #(
-+  e) ac_cv_lib_gif_DGifGetCode=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
--LIBS=$ac_check_lib_save_LIBS
-+LIBS=$ac_check_lib_save_LIBS ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gif_DGifGetCode" >&5
--$as_echo "$ac_cv_lib_gif_DGifGetCode" >&6; }
--if test "x$ac_cv_lib_gif_DGifGetCode" = xyes; then :
--  cat >>confdefs.h <<_ACEOF
--#define HAVE_LIBGIF 1
--_ACEOF
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_gif_DGifGetCode" >&5
-+printf "%s\n" "$ac_cv_lib_gif_DGifGetCode" >&6; }
-+if test "x$ac_cv_lib_gif_DGifGetCode" = xyes
-+then :
-+  printf "%s\n" "#define HAVE_LIBGIF 1" >>confdefs.h
- 
-   LIBS="-lgif $LIBS"
- 
--else
--   as_fn_error $? "--with-giflib=system specified, but no giflib found!" "$LINENO" 5
-+else case e in #(
-+  e)  as_fn_error $? "--with-giflib=system specified, but no giflib found!" "$LINENO" 5 ;;
-+esac
- fi
- 
- 
-@@ -46419,56 +49087,59 @@ fi
- 
- 
- # Check whether --with-zlib was given.
--if test "${with_zlib+set}" = set; then :
-+if test ${with_zlib+y}
-+then :
-   withval=$with_zlib;
- fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for compress in -lz" >&5
--$as_echo_n "checking for compress in -lz... " >&6; }
--if ${ac_cv_lib_z_compress+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_check_lib_save_LIBS=$LIBS
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for compress in -lz" >&5
-+printf %s "checking for compress in -lz... " >&6; }
-+if test ${ac_cv_lib_z_compress+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_check_lib_save_LIBS=$LIBS
- LIBS="-lz  $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--/* Override any GCC internal prototype to avoid an error.
--   Use char because int might match the return type of a GCC
--   builtin and then its argument prototype would still apply.  */
--#ifdef __cplusplus
--extern "C"
--#endif
--char compress ();
-+namespace conftest {
-+  extern "C" int compress ();
-+}
- int
--main ()
-+main (void)
- {
--return compress ();
-+return conftest::compress ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   ac_cv_lib_z_compress=yes
--else
--  ac_cv_lib_z_compress=no
-+else case e in #(
-+  e) ac_cv_lib_z_compress=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
--LIBS=$ac_check_lib_save_LIBS
-+LIBS=$ac_check_lib_save_LIBS ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_compress" >&5
--$as_echo "$ac_cv_lib_z_compress" >&6; }
--if test "x$ac_cv_lib_z_compress" = xyes; then :
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_z_compress" >&5
-+printf "%s\n" "$ac_cv_lib_z_compress" >&6; }
-+if test "x$ac_cv_lib_z_compress" = xyes
-+then :
-    ZLIB_FOUND=yes
--else
--   ZLIB_FOUND=no
-+else case e in #(
-+  e)  ZLIB_FOUND=no  ;;
-+esac
- fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for which zlib to use" >&5
--$as_echo_n "checking for which zlib to use... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for which zlib to use" >&5
-+printf %s "checking for which zlib to use... " >&6; }
- 
-   DEFAULT_ZLIB=bundled
-   if test "x$OPENJDK_TARGET_OS" = xmacosx; then
-@@ -46494,16 +49165,16 @@ $as_echo_n "checking for which zlib to use... " >&6; }
- 
-   if test "x${with_zlib}" = "xbundled"; then
-     USE_EXTERNAL_LIBZ=false
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: bundled" >&5
--$as_echo "bundled" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: bundled" >&5
-+printf "%s\n" "bundled" >&6; }
-   elif test "x${with_zlib}" = "xsystem"; then
-     if test "x${ZLIB_FOUND}" = "xyes"; then
-       USE_EXTERNAL_LIBZ=true
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: system" >&5
--$as_echo "system" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: system" >&5
-+printf "%s\n" "system" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: system not found" >&5
--$as_echo "system not found" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: system not found" >&5
-+printf "%s\n" "system not found" >&6; }
-       as_fn_error $? "--with-zlib=system specified, but no zlib found!" "$LINENO" 5
-     fi
-   else
-@@ -46526,23 +49197,25 @@ $as_echo "system not found" >&6; }
- /* end confdefs.h.  */
- #include <time.h>
- int
--main ()
-+main (void)
- {
- return (int)altzone;
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   has_altzone=yes
--else
--  has_altzone=no
-+else case e in #(
-+  e) has_altzone=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
-   if test "x$has_altzone" = xyes; then
- 
--$as_echo "#define HAVE_ALTZONE 1" >>confdefs.h
-+printf "%s\n" "#define HAVE_ALTZONE 1" >>confdefs.h
- 
-   fi
- 
-@@ -46551,55 +49224,55 @@ $as_echo "#define HAVE_ALTZONE 1" >>confdefs.h
-   # Check the maths library
-   #
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for cos in -lm" >&5
--$as_echo_n "checking for cos in -lm... " >&6; }
--if ${ac_cv_lib_m_cos+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_check_lib_save_LIBS=$LIBS
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for cos in -lm" >&5
-+printf %s "checking for cos in -lm... " >&6; }
-+if test ${ac_cv_lib_m_cos+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_check_lib_save_LIBS=$LIBS
- LIBS="-lm  $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--/* Override any GCC internal prototype to avoid an error.
--   Use char because int might match the return type of a GCC
--   builtin and then its argument prototype would still apply.  */
--#ifdef __cplusplus
--extern "C"
--#endif
--char cos ();
-+namespace conftest {
-+  extern "C" int cos ();
-+}
- int
--main ()
-+main (void)
- {
--return cos ();
-+return conftest::cos ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   ac_cv_lib_m_cos=yes
--else
--  ac_cv_lib_m_cos=no
-+else case e in #(
-+  e) ac_cv_lib_m_cos=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
--LIBS=$ac_check_lib_save_LIBS
-+LIBS=$ac_check_lib_save_LIBS ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_cos" >&5
--$as_echo "$ac_cv_lib_m_cos" >&6; }
--if test "x$ac_cv_lib_m_cos" = xyes; then :
--  cat >>confdefs.h <<_ACEOF
--#define HAVE_LIBM 1
--_ACEOF
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_m_cos" >&5
-+printf "%s\n" "$ac_cv_lib_m_cos" >&6; }
-+if test "x$ac_cv_lib_m_cos" = xyes
-+then :
-+  printf "%s\n" "#define HAVE_LIBM 1" >>confdefs.h
- 
-   LIBS="-lm $LIBS"
- 
--else
--
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Maths library was not found" >&5
--$as_echo "$as_me: Maths library was not found" >&6;}
--
-+else case e in #(
-+  e)
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Maths library was not found" >&5
-+printf "%s\n" "$as_me: Maths library was not found" >&6;}
- 
-+   ;;
-+esac
- fi
- 
- 
-@@ -46610,46 +49283,45 @@ fi
- 
-   save_LIBS="$LIBS"
-   LIBS=""
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
--$as_echo_n "checking for dlopen in -ldl... " >&6; }
--if ${ac_cv_lib_dl_dlopen+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  ac_check_lib_save_LIBS=$LIBS
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
-+printf %s "checking for dlopen in -ldl... " >&6; }
-+if test ${ac_cv_lib_dl_dlopen+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) ac_check_lib_save_LIBS=$LIBS
- LIBS="-ldl  $LIBS"
- cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
--/* Override any GCC internal prototype to avoid an error.
--   Use char because int might match the return type of a GCC
--   builtin and then its argument prototype would still apply.  */
--#ifdef __cplusplus
--extern "C"
--#endif
--char dlopen ();
-+namespace conftest {
-+  extern "C" int dlopen ();
-+}
- int
--main ()
-+main (void)
- {
--return dlopen ();
-+return conftest::dlopen ();
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   ac_cv_lib_dl_dlopen=yes
--else
--  ac_cv_lib_dl_dlopen=no
-+else case e in #(
-+  e) ac_cv_lib_dl_dlopen=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
--LIBS=$ac_check_lib_save_LIBS
-+LIBS=$ac_check_lib_save_LIBS ;;
-+esac
- fi
--{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
--$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
--if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
--  cat >>confdefs.h <<_ACEOF
--#define HAVE_LIBDL 1
--_ACEOF
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
-+printf "%s\n" "$ac_cv_lib_dl_dlopen" >&6; }
-+if test "x$ac_cv_lib_dl_dlopen" = xyes
-+then :
-+  printf "%s\n" "#define HAVE_LIBDL 1" >>confdefs.h
- 
-   LIBS="-ldl $LIBS"
- 
-@@ -46667,23 +49339,25 @@ fi
-   #
- 
- # Check whether --with-stdc++lib was given.
--if test "${with_stdc__lib+set}" = set; then :
-+if test ${with_stdc__lib+y}
-+then :
-   withval=$with_stdc__lib;
-         if test "x$with_stdc__lib" != xdynamic && test "x$with_stdc__lib" != xstatic \
-                 && test "x$with_stdc__lib" != xdefault; then
-           as_fn_error $? "Bad parameter value --with-stdc++lib=$with_stdc__lib!" "$LINENO" 5
-         fi
- 
--else
--  with_stdc__lib=default
--
-+else case e in #(
-+  e) with_stdc__lib=default
-+   ;;
-+esac
- fi
- 
- 
-   if test "x$OPENJDK_TARGET_OS" = xlinux; then
-     # Test if -lstdc++ works.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if dynamic link of stdc++ is possible" >&5
--$as_echo_n "checking if dynamic link of stdc++ is possible... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if dynamic link of stdc++ is possible" >&5
-+printf %s "checking if dynamic link of stdc++ is possible... " >&6; }
-     ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
- ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-@@ -46696,19 +49370,21 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- return 0;
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   has_dynamic_libstdcxx=yes
--else
--  has_dynamic_libstdcxx=no
-+else case e in #(
-+  e) has_dynamic_libstdcxx=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
-     CXXFLAGS="$OLD_CXXFLAGS"
-     ac_ext=cpp
-@@ -46717,12 +49393,12 @@ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
- ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
- ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_dynamic_libstdcxx" >&5
--$as_echo "$has_dynamic_libstdcxx" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $has_dynamic_libstdcxx" >&5
-+printf "%s\n" "$has_dynamic_libstdcxx" >&6; }
- 
-     # Test if stdc++ can be linked statically.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if static link of stdc++ is possible" >&5
--$as_echo_n "checking if static link of stdc++ is possible... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if static link of stdc++ is possible" >&5
-+printf %s "checking if static link of stdc++ is possible... " >&6; }
-     STATIC_STDCXX_FLAGS="-Wl,-Bstatic -lstdc++ -lgcc -Wl,-Bdynamic"
-     ac_ext=cpp
- ac_cpp='$CXXCPP $CPPFLAGS'
-@@ -46738,19 +49414,21 @@ ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- return 0;
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_link "$LINENO"; then :
-+if ac_fn_cxx_try_link "$LINENO"
-+then :
-   has_static_libstdcxx=yes
--else
--  has_static_libstdcxx=no
-+else case e in #(
-+  e) has_static_libstdcxx=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext \
-+rm -f core conftest.err conftest.$ac_objext conftest.beam \
-     conftest$ac_exeext conftest.$ac_ext
-     LIBS="$OLD_LIBS"
-     CXX="$OLD_CXX"
-@@ -46760,8 +49438,8 @@ ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
- ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
- ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
- 
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $has_static_libstdcxx" >&5
--$as_echo "$has_static_libstdcxx" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $has_static_libstdcxx" >&5
-+printf "%s\n" "$has_static_libstdcxx" >&6; }
- 
-     if test "x$has_static_libstdcxx" = xno && test "x$has_dynamic_libstdcxx" = xno; then
-       as_fn_error $? "Cannot link to stdc++, neither dynamically nor statically!" "$LINENO" 5
-@@ -46775,22 +49453,22 @@ $as_echo "$has_static_libstdcxx" >&6; }
-       as_fn_error $? "Dynamic linking of libstdc++ was not possible!" "$LINENO" 5
-     fi
- 
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to link with libstdc++" >&5
--$as_echo_n "checking how to link with libstdc++... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking how to link with libstdc++" >&5
-+printf %s "checking how to link with libstdc++... " >&6; }
-     # If dynamic was requested, it's available since it would fail above otherwise.
-     # If dynamic wasn't requested, go with static unless it isn't available.
-     if test "x$with_stdc__lib" = xdynamic || test "x$has_static_libstdcxx" = xno || test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
-       LIBCXX="$LIBCXX -lstdc++"
-       LDCXX="$CXX"
-       STATIC_CXX_SETTING="STATIC_CXX=false"
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: dynamic" >&5
--$as_echo "dynamic" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: dynamic" >&5
-+printf "%s\n" "dynamic" >&6; }
-     else
-       LIBCXX="$LIBCXX $STATIC_STDCXX_FLAGS"
-       LDCXX="$CC"
-       STATIC_CXX_SETTING="STATIC_CXX=true"
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: static" >&5
--$as_echo "static" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: static" >&5
-+printf "%s\n" "static" >&6; }
-     fi
-   fi
- 
-@@ -46799,17 +49477,17 @@ $as_echo "static" >&6; }
-     # Figure out LIBFFI_CFLAGS and LIBFFI_LIBS
- 
- pkg_failed=no
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for LIBFFI" >&5
--$as_echo_n "checking for LIBFFI... " >&6; }
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for LIBFFI" >&5
-+printf %s "checking for LIBFFI... " >&6; }
- 
- if test -n "$LIBFFI_CFLAGS"; then
-     pkg_cv_LIBFFI_CFLAGS="$LIBFFI_CFLAGS"
-  elif test -n "$PKG_CONFIG"; then
-     if test -n "$PKG_CONFIG" && \
--    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libffi\""; } >&5
-+    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libffi\""; } >&5
-   ($PKG_CONFIG --exists --print-errors "libffi") 2>&5
-   ac_status=$?
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; }; then
-   pkg_cv_LIBFFI_CFLAGS=`$PKG_CONFIG --cflags "libffi" 2>/dev/null`
- else
-@@ -46822,10 +49500,10 @@ if test -n "$LIBFFI_LIBS"; then
-     pkg_cv_LIBFFI_LIBS="$LIBFFI_LIBS"
-  elif test -n "$PKG_CONFIG"; then
-     if test -n "$PKG_CONFIG" && \
--    { { $as_echo "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libffi\""; } >&5
-+    { { printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$PKG_CONFIG --exists --print-errors \"libffi\""; } >&5
-   ($PKG_CONFIG --exists --print-errors "libffi") 2>&5
-   ac_status=$?
--  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-+  printf "%s\n" "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-   test $ac_status = 0; }; then
-   pkg_cv_LIBFFI_LIBS=`$PKG_CONFIG --libs "libffi" 2>/dev/null`
- else
-@@ -46864,8 +49542,8 @@ and LIBFFI_LIBS to avoid the need to call pkg-config.
- See the pkg-config man page for more details.
- " "$LINENO" 5
- elif test $pkg_failed = untried; then
--	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
--$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-+	{ { printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: in '$ac_pwd':" >&5
-+printf "%s\n" "$as_me: error: in '$ac_pwd':" >&2;}
- as_fn_error $? "The pkg-config script could not be found or is too old.  Make sure it
- is in your PATH or set the PKG_CONFIG environment variable to the full
- path to pkg-config.
-@@ -46875,12 +49553,12 @@ and LIBFFI_LIBS to avoid the need to call pkg-config.
- See the pkg-config man page for more details.
- 
- To get pkg-config, see <http://pkg-config.freedesktop.org/>.
--See \`config.log' for more details" "$LINENO" 5; }
-+See 'config.log' for more details" "$LINENO" 5; }
- else
- 	LIBFFI_CFLAGS=$pkg_cv_LIBFFI_CFLAGS
- 	LIBFFI_LIBS=$pkg_cv_LIBFFI_LIBS
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
- 	:
- fi
- 
-@@ -46889,38 +49567,44 @@ fi
-   if test "x$JVM_VARIANT_ZEROSHARK" = xtrue; then
-     # Extract the first word of "llvm-config", so it can be a program name with args.
- set dummy llvm-config; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_prog_LLVM_CONFIG+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  if test -n "$LLVM_CONFIG"; then
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_prog_LLVM_CONFIG+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) if test -n "$LLVM_CONFIG"; then
-   ac_cv_prog_LLVM_CONFIG="$LLVM_CONFIG" # Let the user override the test.
- else
- as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-     ac_cv_prog_LLVM_CONFIG="llvm-config"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-   done
- IFS=$as_save_IFS
- 
--fi
-+fi ;;
-+esac
- fi
- LLVM_CONFIG=$ac_cv_prog_LLVM_CONFIG
- if test -n "$LLVM_CONFIG"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LLVM_CONFIG" >&5
--$as_echo "$LLVM_CONFIG" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $LLVM_CONFIG" >&5
-+printf "%s\n" "$LLVM_CONFIG" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -46990,7 +49674,8 @@ fi
- 
- 
- # Check whether --with-msvcr-dll was given.
--if test "${with_msvcr_dll+set}" = set; then :
-+if test ${with_msvcr_dll+y}
-+then :
-   withval=$with_msvcr_dll;
- fi
- 
-@@ -47002,12 +49687,12 @@ fi
-   POSSIBLE_MSVC_DLL="$with_msvcr_dll"
-   METHOD="--with-msvcr-dll"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -47025,8 +49710,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -47048,8 +49733,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -47097,8 +49782,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -47135,8 +49820,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -47147,8 +49832,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -47161,15 +49846,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -47183,12 +49868,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$DEVKIT_MSVCR_DLL"
-   METHOD="devkit"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -47206,8 +49891,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -47229,8 +49914,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -47278,8 +49963,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -47316,8 +50001,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -47328,8 +50013,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -47342,15 +50027,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -47386,8 +50071,8 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of CYGWIN_VC_INSTALL_DIR" "$LINENO" 5
-   fi
- 
-@@ -47435,8 +50120,8 @@ $as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\"
- 
-   if test "x$path" != "x$new_path"; then
-     CYGWIN_VC_INSTALL_DIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -47473,8 +50158,8 @@ $as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     CYGWIN_VC_INSTALL_DIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -47485,8 +50170,8 @@ $as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-     path="$CYGWIN_VC_INSTALL_DIR"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -47522,12 +50207,12 @@ $as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\"
-   POSSIBLE_MSVC_DLL="$possible_msvc_dll"
-   METHOD="well-known location in VCINSTALLDIR"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -47545,8 +50230,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -47568,8 +50253,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -47617,8 +50302,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -47655,8 +50340,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -47667,8 +50352,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -47681,15 +50366,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -47705,12 +50390,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
-   METHOD="well-known location in Boot JDK"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -47728,8 +50413,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -47751,8 +50436,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -47800,8 +50485,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -47838,8 +50523,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -47850,8 +50535,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -47864,15 +50549,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -47897,12 +50582,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
-   METHOD="well-known location in SYSTEMROOT"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -47920,8 +50605,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -47943,8 +50628,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -47992,8 +50677,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -48030,8 +50715,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -48042,8 +50727,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -48056,15 +50741,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -48096,12 +50781,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
-   METHOD="search of VS100COMNTOOLS"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -48119,8 +50804,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -48142,8 +50827,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -48191,8 +50876,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -48229,8 +50914,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -48241,8 +50926,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -48255,15 +50940,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -48292,12 +50977,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
-   METHOD="search of VCINSTALLDIR"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -48315,8 +51000,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -48338,8 +51023,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -48387,8 +51072,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -48425,8 +51110,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -48437,8 +51122,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -48451,15 +51136,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -48467,10 +51152,10 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   fi
- 
-   if test "x$MSVC_DLL" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-     as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
-   fi
- 
-@@ -48480,7 +51165,8 @@ $as_echo "no" >&6; }
- 
- 
- # Check whether --with-msvcp-dll was given.
--if test "${with_msvcp_dll+set}" = set; then :
-+if test ${with_msvcp_dll+y}
-+then :
-   withval=$with_msvcp_dll;
- fi
- 
-@@ -48493,12 +51179,12 @@ fi
-   POSSIBLE_MSVC_DLL="$with_msvcp_dll"
-   METHOD="--with-msvcp-dll"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -48516,8 +51202,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -48539,8 +51225,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -48588,8 +51274,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -48626,8 +51312,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -48638,8 +51324,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -48652,15 +51338,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -48674,12 +51360,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$DEVKIT_MSVCP_DLL"
-   METHOD="devkit"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -48697,8 +51383,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -48720,8 +51406,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -48769,8 +51455,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -48807,8 +51493,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -48819,8 +51505,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -48833,15 +51519,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -48877,8 +51563,8 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of CYGWIN_VC_INSTALL_DIR" "$LINENO" 5
-   fi
- 
-@@ -48926,8 +51612,8 @@ $as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\"
- 
-   if test "x$path" != "x$new_path"; then
-     CYGWIN_VC_INSTALL_DIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -48964,8 +51650,8 @@ $as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     CYGWIN_VC_INSTALL_DIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -48976,8 +51662,8 @@ $as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-     path="$CYGWIN_VC_INSTALL_DIR"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -49013,12 +51699,12 @@ $as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\"
-   POSSIBLE_MSVC_DLL="$possible_msvc_dll"
-   METHOD="well-known location in VCINSTALLDIR"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -49036,8 +51722,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -49059,8 +51745,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -49108,8 +51794,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -49146,8 +51832,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -49158,8 +51844,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -49172,15 +51858,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -49196,12 +51882,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
-   METHOD="well-known location in Boot JDK"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -49219,8 +51905,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -49242,8 +51928,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -49291,8 +51977,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -49329,8 +52015,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -49341,8 +52027,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -49355,15 +52041,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -49388,12 +52074,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
-   METHOD="well-known location in SYSTEMROOT"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -49411,8 +52097,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -49434,8 +52120,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -49483,8 +52169,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -49521,8 +52207,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -49533,8 +52219,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -49547,15 +52233,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -49587,12 +52273,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
-   METHOD="search of VS100COMNTOOLS"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -49610,8 +52296,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -49633,8 +52319,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -49682,8 +52368,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -49720,8 +52406,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -49732,8 +52418,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -49746,15 +52432,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -49783,12 +52469,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
-   METHOD="search of VCINSTALLDIR"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -49806,8 +52492,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -49829,8 +52515,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -49878,8 +52564,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -49916,8 +52602,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -49928,8 +52614,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -49942,15 +52628,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -49958,10 +52644,10 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   fi
- 
-   if test "x$MSVC_DLL" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-     as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
-   fi
- 
-@@ -49972,7 +52658,8 @@ $as_echo "no" >&6; }
- 
- 
- # Check whether --with-vcruntime-1-dll was given.
--if test "${with_vcruntime_1_dll+set}" = set; then :
-+if test ${with_vcruntime_1_dll+y}
-+then :
-   withval=$with_vcruntime_1_dll;
- fi
- 
-@@ -49985,12 +52672,12 @@ fi
-   POSSIBLE_MSVC_DLL="$with_vcruntime_1_dll"
-   METHOD="--with-vcruntime-1-dll"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -50008,8 +52695,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -50031,8 +52718,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -50080,8 +52767,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -50118,8 +52805,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -50130,8 +52817,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -50144,15 +52831,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -50166,12 +52853,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$DEVKIT_VCRUNTIME_1_DLL"
-   METHOD="devkit"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -50189,8 +52876,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -50212,8 +52899,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -50261,8 +52948,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -50299,8 +52986,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -50311,8 +52998,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -50325,15 +53012,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -50369,8 +53056,8 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of CYGWIN_VC_INSTALL_DIR" "$LINENO" 5
-   fi
- 
-@@ -50418,8 +53105,8 @@ $as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\"
- 
-   if test "x$path" != "x$new_path"; then
-     CYGWIN_VC_INSTALL_DIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -50456,8 +53143,8 @@ $as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     CYGWIN_VC_INSTALL_DIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -50468,8 +53155,8 @@ $as_echo "$as_me: Rewriting CYGWIN_VC_INSTALL_DIR to \"$new_path\"" >&6;}
-     path="$CYGWIN_VC_INSTALL_DIR"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -50505,12 +53192,12 @@ $as_echo "$as_me: The path of CYGWIN_VC_INSTALL_DIR, which resolves as \"$path\"
-   POSSIBLE_MSVC_DLL="$possible_msvc_dll"
-   METHOD="well-known location in VCINSTALLDIR"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -50528,8 +53215,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -50551,8 +53238,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -50600,8 +53287,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -50638,8 +53325,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -50650,8 +53337,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -50664,15 +53351,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -50688,12 +53375,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
-   METHOD="well-known location in Boot JDK"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -50711,8 +53398,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -50734,8 +53421,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -50783,8 +53470,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -50821,8 +53508,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -50833,8 +53520,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -50847,15 +53534,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -50880,12 +53567,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
-   METHOD="well-known location in SYSTEMROOT"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -50903,8 +53590,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -50926,8 +53613,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -50975,8 +53662,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -51013,8 +53700,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -51025,8 +53712,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -51039,15 +53726,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -51079,12 +53766,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
-   METHOD="search of VS100COMNTOOLS"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -51102,8 +53789,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -51125,8 +53812,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -51174,8 +53861,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -51212,8 +53899,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -51224,8 +53911,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -51238,15 +53925,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -51275,12 +53962,12 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   POSSIBLE_MSVC_DLL="$POSSIBLE_MSVC_DLL"
-   METHOD="search of VCINSTALLDIR"
-   if test -n "$POSSIBLE_MSVC_DLL" -a -e "$POSSIBLE_MSVC_DLL"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
--$as_echo "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&5
-+printf "%s\n" "$as_me: Found $DLL_NAME at $POSSIBLE_MSVC_DLL using $METHOD" >&6;}
- 
-     # Need to check if the found msvcr is correct architecture
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
--$as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking found $DLL_NAME architecture" >&5
-+printf %s "checking found $DLL_NAME architecture... " >&6; }
-     MSVC_DLL_FILETYPE=`$FILE -b "$POSSIBLE_MSVC_DLL"`
-     if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-       # The MSYS 'file' command returns "PE32 executable for MS Windows (DLL) (GUI) Intel 80386 32-bit"
-@@ -51298,8 +53985,8 @@ $as_echo_n "checking found $DLL_NAME architecture... " >&6; }
-       fi
-     fi
-     if $ECHO "$MSVC_DLL_FILETYPE" | $GREP "$CORRECT_MSVCR_ARCH" 2>&1 > /dev/null; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
--$as_echo "ok" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: ok" >&5
-+printf "%s\n" "ok" >&6; }
-       MSVC_DLL="$POSSIBLE_MSVC_DLL"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -51321,8 +54008,8 @@ $as_echo "ok" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of MSVC_DLL" "$LINENO" 5
-   fi
- 
-@@ -51370,8 +54057,8 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -51408,8 +54095,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     MSVC_DLL="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting MSVC_DLL to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -51420,8 +54107,8 @@ $as_echo "$as_me: Rewriting MSVC_DLL to \"$new_path\"" >&6;}
-     path="$MSVC_DLL"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -51434,15 +54121,15 @@ $as_echo "$as_me: The path of MSVC_DLL, which resolves as \"$path\", is invalid.
-     MSVC_DLL="`cd "$path"; $THEPWDCMD -L`"
-   fi
- 
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
--$as_echo "$MSVC_DLL" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MSVC_DLL" >&5
-+printf "%s\n" "$MSVC_DLL" >&6; }
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
--$as_echo "incorrect, ignoring" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
--$as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: incorrect, ignoring" >&5
-+printf "%s\n" "incorrect, ignoring" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&5
-+printf "%s\n" "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE" >&6;}
-     fi
-   fi
- 
-@@ -51450,10 +54137,10 @@ $as_echo "$as_me: The file type of the located $DLL_NAME is $MSVC_DLL_FILETYPE"
-   fi
- 
-   if test "x$MSVC_DLL" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
--$as_echo_n "checking for $DLL_NAME... " >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $DLL_NAME" >&5
-+printf %s "checking for $DLL_NAME... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-     as_fn_error $? "Could not find $DLL_NAME. Please specify using --with-msvcr-dll." "$LINENO" 5
-   fi
- 
-@@ -51464,22 +54151,23 @@ $as_echo "no" >&6; }
- 
- 
- # Check whether --with-ucrt-dll-dir was given.
--if test "${with_ucrt_dll_dir+set}" = set; then :
-+if test ${with_ucrt_dll_dir+y}
-+then :
-   withval=$with_ucrt_dll_dir;
- fi
- 
- 
-   if test "x$USE_UCRT" = "xtrue"; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for UCRT DLL dir" >&5
--$as_echo_n "checking for UCRT DLL dir... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for UCRT DLL dir" >&5
-+printf %s "checking for UCRT DLL dir... " >&6; }
-     if test "x$with_ucrt_dll_dir" != x; then
-       if test -z "$(ls -d "$with_ucrt_dll_dir/"*.dll 2> /dev/null)"; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-         as_fn_error $? "Could not find any dlls in $with_ucrt_dll_dir" "$LINENO" 5
-       else
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_ucrt_dll_dir" >&5
--$as_echo "$with_ucrt_dll_dir" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $with_ucrt_dll_dir" >&5
-+printf "%s\n" "$with_ucrt_dll_dir" >&6; }
-         UCRT_DLL_DIR="$with_ucrt_dll_dir"
- 
-   if test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.cygwin"; then
-@@ -51501,8 +54189,8 @@ $as_echo "$with_ucrt_dll_dir" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of UCRT_DLL_DIR" "$LINENO" 5
-   fi
- 
-@@ -51550,8 +54238,8 @@ $as_echo "$as_me: The path of UCRT_DLL_DIR, which resolves as \"$path\", is inva
- 
-   if test "x$path" != "x$new_path"; then
-     UCRT_DLL_DIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -51588,8 +54276,8 @@ $as_echo "$as_me: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     UCRT_DLL_DIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -51600,8 +54288,8 @@ $as_echo "$as_me: Rewriting UCRT_DLL_DIR to \"$new_path\"" >&6;}
-     path="$UCRT_DLL_DIR"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of UCRT_DLL_DIR, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -51617,8 +54305,8 @@ $as_echo "$as_me: The path of UCRT_DLL_DIR, which resolves as \"$path\", is inva
-       fi
-     elif test "x$DEVKIT_UCRT_DLL_DIR" != "x"; then
-       UCRT_DLL_DIR="$DEVKIT_UCRT_DLL_DIR"
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UCRT_DLL_DIR" >&5
--$as_echo "$UCRT_DLL_DIR" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UCRT_DLL_DIR" >&5
-+printf "%s\n" "$UCRT_DLL_DIR" >&6; }
-     else
-       CYGWIN_WINDOWSSDKDIR="${WINDOWSSDKDIR}"
- 
-@@ -51641,8 +54329,8 @@ $as_echo "$UCRT_DLL_DIR" >&6; }
-   # It is also a way to make sure we got the proper file name for the real test later on.
-   test_shortpath=`$CYGPATH -s -m "$new_path" 2> /dev/null`
-   if test "x$test_shortpath" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&6;}
-     as_fn_error $? "Cannot locate the the path of CYGWIN_WINDOWSSDKDIR" "$LINENO" 5
-   fi
- 
-@@ -51690,8 +54378,8 @@ $as_echo "$as_me: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\",
- 
-   if test "x$path" != "x$new_path"; then
-     CYGWIN_WINDOWSSDKDIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&6;}
-   fi
- 
-   elif test "x$OPENJDK_BUILD_OS_ENV" = "xwindows.msys"; then
-@@ -51728,8 +54416,8 @@ $as_echo "$as_me: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&6;}
- 
-   if test "x$path" != "x$new_path"; then
-     CYGWIN_WINDOWSSDKDIR="$new_path"
--    { $as_echo "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&5
--$as_echo "$as_me: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&5
-+printf "%s\n" "$as_me: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&6;}
-   fi
- 
-   # Save the first 10 bytes of this path to the storage, so fixpath can work.
-@@ -51740,8 +54428,8 @@ $as_echo "$as_me: Rewriting CYGWIN_WINDOWSSDKDIR to \"$new_path\"" >&6;}
-     path="$CYGWIN_WINDOWSSDKDIR"
-     has_space=`$ECHO "$path" | $GREP " "`
-     if test "x$has_space" != x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&5
--$as_echo "$as_me: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&5
-+printf "%s\n" "$as_me: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\", is invalid." >&6;}
-       as_fn_error $? "Spaces are not allowed in this path." "$LINENO" 5
-     fi
- 
-@@ -51765,16 +54453,16 @@ $as_echo "$as_me: The path of CYGWIN_WINDOWSSDKDIR, which resolves as \"$path\",
-             2> /dev/null | $SORT -d | $HEAD -n1`"
-         if test -z "$UCRT_DLL_DIR" \
-             || test -z "$(ls -d "$UCRT_DLL_DIR/"*.dll 2> /dev/null)"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-           as_fn_error $? "Could not find any dlls in $UCRT_DLL_DIR" "$LINENO" 5
-         else
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UCRT_DLL_DIR" >&5
--$as_echo "$UCRT_DLL_DIR" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UCRT_DLL_DIR" >&5
-+printf "%s\n" "$UCRT_DLL_DIR" >&6; }
-         fi
-       else
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $UCRT_DLL_DIR" >&5
--$as_echo "$UCRT_DLL_DIR" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $UCRT_DLL_DIR" >&5
-+printf "%s\n" "$UCRT_DLL_DIR" >&6; }
-       fi
-     fi
-   else
-@@ -51785,27 +54473,30 @@ $as_echo "$UCRT_DLL_DIR" >&6; }
- 
- 
- # Check whether --with-dxsdk was given.
--if test "${with_dxsdk+set}" = set; then :
--  withval=$with_dxsdk; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&5
--$as_echo "$as_me: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&2;}
-+if test ${with_dxsdk+y}
-+then :
-+  withval=$with_dxsdk; { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&5
-+printf "%s\n" "$as_me: WARNING: Option --with-dxsdk is deprecated and will be ignored." >&2;}
- fi
- 
- 
- 
- 
- # Check whether --with-dxsdk-lib was given.
--if test "${with_dxsdk_lib+set}" = set; then :
--  withval=$with_dxsdk_lib; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&5
--$as_echo "$as_me: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&2;}
-+if test ${with_dxsdk_lib+y}
-+then :
-+  withval=$with_dxsdk_lib; { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&5
-+printf "%s\n" "$as_me: WARNING: Option --with-dxsdk-lib is deprecated and will be ignored." >&2;}
- fi
- 
- 
- 
- 
- # Check whether --with-dxsdk-include was given.
--if test "${with_dxsdk_include+set}" = set; then :
--  withval=$with_dxsdk_include; { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&5
--$as_echo "$as_me: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&2;}
-+if test ${with_dxsdk_include+y}
-+then :
-+  withval=$with_dxsdk_include; { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&5
-+printf "%s\n" "$as_me: WARNING: Option --with-dxsdk-include is deprecated and will be ignored." >&2;}
- fi
- 
- 
-@@ -51830,17 +54521,17 @@ fi
- 
- 
- 
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if elliptic curve crypto implementation is present" >&5
--$as_echo_n "checking if elliptic curve crypto implementation is present... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if elliptic curve crypto implementation is present" >&5
-+printf %s "checking if elliptic curve crypto implementation is present... " >&6; }
- 
-     if test -d "${SRC_ROOT}/jdk/src/share/native/sun/security/ec/impl"; then
-       ENABLE_INTREE_EC=yes
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
-     else
-       ENABLE_INTREE_EC=no
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-     fi
- 
- 
-@@ -51857,15 +54548,16 @@ $as_echo "no" >&6; }
-   # How many cores do we have on this build system?
- 
- # Check whether --with-num-cores was given.
--if test "${with_num_cores+set}" = set; then :
-+if test ${with_num_cores+y}
-+then :
-   withval=$with_num_cores;
- fi
- 
-   if test "x$with_num_cores" = x; then
-     # The number of cores were not specified, try to probe them.
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for number of cores" >&5
--$as_echo_n "checking for number of cores... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for number of cores" >&5
-+printf %s "checking for number of cores... " >&6; }
-   NUM_CORES=1
-   FOUND_CORES=no
- 
-@@ -51894,13 +54586,13 @@ $as_echo_n "checking for number of cores... " >&6; }
-   fi
- 
-   if test "x$FOUND_CORES" = xyes; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NUM_CORES" >&5
--$as_echo "$NUM_CORES" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $NUM_CORES" >&5
-+printf "%s\n" "$NUM_CORES" >&6; }
-   else
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not detect number of cores, defaulting to 1" >&5
--$as_echo "could not detect number of cores, defaulting to 1" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This will disable all parallelism from build!" >&5
--$as_echo "$as_me: WARNING: This will disable all parallelism from build!" >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: could not detect number of cores, defaulting to 1" >&5
-+printf "%s\n" "could not detect number of cores, defaulting to 1" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: This will disable all parallelism from build!" >&5
-+printf "%s\n" "$as_me: WARNING: This will disable all parallelism from build!" >&2;}
-   fi
- 
-   else
-@@ -51912,15 +54604,16 @@ $as_echo "$as_me: WARNING: This will disable all parallelism from build!" >&2;}
-   # How much memory do we have on this build system?
- 
- # Check whether --with-memory-size was given.
--if test "${with_memory_size+set}" = set; then :
-+if test ${with_memory_size+y}
-+then :
-   withval=$with_memory_size;
- fi
- 
-   if test "x$with_memory_size" = x; then
-     # The memory size was not specified, try to probe it.
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for memory size" >&5
--$as_echo_n "checking for memory size... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for memory size" >&5
-+printf %s "checking for memory size... " >&6; }
-   # Default to 1024 MB
-   MEMORY_SIZE=1024
-   FOUND_MEM=no
-@@ -51947,13 +54640,13 @@ $as_echo_n "checking for memory size... " >&6; }
-   fi
- 
-   if test "x$FOUND_MEM" = xyes; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MEMORY_SIZE MB" >&5
--$as_echo "$MEMORY_SIZE MB" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $MEMORY_SIZE MB" >&5
-+printf "%s\n" "$MEMORY_SIZE MB" >&6; }
-   else
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: could not detect memory size, defaulting to 1024 MB" >&5
--$as_echo "could not detect memory size, defaulting to 1024 MB" >&6; }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: This might seriously impact build performance!" >&5
--$as_echo "$as_me: WARNING: This might seriously impact build performance!" >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: could not detect memory size, defaulting to 1024 MB" >&5
-+printf "%s\n" "could not detect memory size, defaulting to 1024 MB" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: This might seriously impact build performance!" >&5
-+printf "%s\n" "$as_me: WARNING: This might seriously impact build performance!" >&2;}
-   fi
- 
-   else
-@@ -51966,14 +54659,15 @@ $as_echo "$as_me: WARNING: This might seriously impact build performance!" >&2;}
-   # number of cores, amount of memory and machine architecture.
- 
- # Check whether --with-jobs was given.
--if test "${with_jobs+set}" = set; then :
-+if test ${with_jobs+y}
-+then :
-   withval=$with_jobs;
- fi
- 
-   if test "x$with_jobs" = x; then
-     # Number of jobs was not specified, calculate.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for appropriate number of jobs to run in parallel" >&5
--$as_echo_n "checking for appropriate number of jobs to run in parallel... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for appropriate number of jobs to run in parallel" >&5
-+printf %s "checking for appropriate number of jobs to run in parallel... " >&6; }
-     # Approximate memory in GB, rounding up a bit.
-     memory_gb=`expr $MEMORY_SIZE / 1100`
-     # Pick the lowest of memory in gb and number of cores.
-@@ -51993,8 +54687,8 @@ $as_echo_n "checking for appropriate number of jobs to run in parallel... " >&6;
-     if test "$JOBS" -eq "0"; then
-       JOBS=1
-     fi
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $JOBS" >&5
--$as_echo "$JOBS" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $JOBS" >&5
-+printf "%s\n" "$JOBS" >&6; }
-   else
-     JOBS=$with_jobs
-   fi
-@@ -52005,7 +54699,8 @@ $as_echo "$JOBS" >&6; }
- 
- 
- # Check whether --with-sjavac-server-java was given.
--if test "${with_sjavac_server_java+set}" = set; then :
-+if test ${with_sjavac_server_java+y}
-+then :
-   withval=$with_sjavac_server_java;
- fi
- 
-@@ -52198,17 +54893,19 @@ fi
- 
-   fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to use sjavac" >&5
--$as_echo_n "checking whether to use sjavac... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking whether to use sjavac" >&5
-+printf %s "checking whether to use sjavac... " >&6; }
-   # Check whether --enable-sjavac was given.
--if test "${enable_sjavac+set}" = set; then :
-+if test ${enable_sjavac+y}
-+then :
-   enableval=$enable_sjavac; ENABLE_SJAVAC="${enableval}"
--else
--  ENABLE_SJAVAC='no'
-+else case e in #(
-+  e) ENABLE_SJAVAC='no' ;;
-+esac
- fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ENABLE_SJAVAC" >&5
--$as_echo "$ENABLE_SJAVAC" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $ENABLE_SJAVAC" >&5
-+printf "%s\n" "$ENABLE_SJAVAC" >&6; }
- 
- 
-   if test "x$ENABLE_SJAVAC" = xyes; then
-@@ -52227,10 +54924,12 @@ $as_echo "$ENABLE_SJAVAC" >&6; }
-   # Can the C/C++ compiler use precompiled headers?
-   #
-   # Check whether --enable-precompiled-headers was given.
--if test "${enable_precompiled_headers+set}" = set; then :
-+if test ${enable_precompiled_headers+y}
-+then :
-   enableval=$enable_precompiled_headers; ENABLE_PRECOMPH=${enable_precompiled_headers}
--else
--  ENABLE_PRECOMPH=yes
-+else case e in #(
-+  e) ENABLE_PRECOMPH=yes ;;
-+esac
- fi
- 
- 
-@@ -52242,17 +54941,17 @@ fi
-   if test "x$ENABLE_PRECOMPH" = xyes; then
-     # Check that the compiler actually supports precomp headers.
-     if test "x$TOOLCHAIN_TYPE" = xgcc; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking that precompiled headers work" >&5
--$as_echo_n "checking that precompiled headers work... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking that precompiled headers work" >&5
-+printf %s "checking that precompiled headers work... " >&6; }
-       echo "int alfa();" > conftest.h
-       $CXX -x c++-header conftest.h -o conftest.hpp.gch 2>&5 >&5
-       if test ! -f conftest.hpp.gch; then
-         USE_PRECOMPILED_HEADER=0
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-       else
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
-       fi
-       rm -f conftest.h conftest.hpp.gch
-     fi
-@@ -52264,18 +54963,19 @@ $as_echo "yes" >&6; }
- # Setup use of ccache, if available
- 
-   # Check whether --enable-ccache was given.
--if test "${enable_ccache+set}" = set; then :
-+if test ${enable_ccache+y}
-+then :
-   enableval=$enable_ccache;
- fi
- 
- 
-   CCACHE=
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking is ccache enabled" >&5
--$as_echo_n "checking is ccache enabled... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking is ccache enabled" >&5
-+printf %s "checking is ccache enabled... " >&6; }
-   ENABLE_CCACHE=$enable_ccache
-   if test "x$enable_ccache" = xyes; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
-     OLD_PATH="$PATH"
-     if test "x$TOOLCHAIN_PATH" != x; then
-       PATH=$TOOLCHAIN_PATH:$PATH
-@@ -52292,12 +54992,13 @@ $as_echo "yes" >&6; }
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CCACHE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CCACHE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CCACHE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CCACHE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
-   ;;
-@@ -52306,11 +55007,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CCACHE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -52318,15 +55023,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CCACHE=$ac_cv_path_CCACHE
- if test -n "$CCACHE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
--$as_echo "$CCACHE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
-+printf "%s\n" "$CCACHE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -52342,20 +55048,21 @@ done
-       # If it failed, the variable was not from the command line. Ignore it,
-       # but warn the user (except for BASH, which is always set by the calling BASH).
-       if test "xCCACHE" != xBASH; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&5
--$as_echo "$as_me: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&2;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&5
-+printf "%s\n" "$as_me: WARNING: Ignoring value of CCACHE from the environment. Use command line variables instead." >&2;}
-       fi
-       # Try to locate tool using the code snippet
-       for ac_prog in ccache
- do
-   # Extract the first word of "$ac_prog", so it can be a program name with args.
- set dummy $ac_prog; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CCACHE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CCACHE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CCACHE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CCACHE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
-   ;;
-@@ -52364,11 +55071,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CCACHE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -52376,15 +55087,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CCACHE=$ac_cv_path_CCACHE
- if test -n "$CCACHE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
--$as_echo "$CCACHE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
-+printf "%s\n" "$CCACHE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -52404,16 +55116,17 @@ done
-       tool_basename="${tool_specified##*/}"
-       if test "x$tool_basename" = "x$tool_specified"; then
-         # A command without a complete path is provided, search $PATH.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CCACHE=$tool_basename" >&5
--$as_echo "$as_me: Will search for user supplied tool CCACHE=$tool_basename" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will search for user supplied tool CCACHE=$tool_basename" >&5
-+printf "%s\n" "$as_me: Will search for user supplied tool CCACHE=$tool_basename" >&6;}
-         # Extract the first word of "$tool_basename", so it can be a program name with args.
- set dummy $tool_basename; ac_word=$2
--{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
--$as_echo_n "checking for $ac_word... " >&6; }
--if ${ac_cv_path_CCACHE+:} false; then :
--  $as_echo_n "(cached) " >&6
--else
--  case $CCACHE in
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-+printf %s "checking for $ac_word... " >&6; }
-+if test ${ac_cv_path_CCACHE+y}
-+then :
-+  printf %s "(cached) " >&6
-+else case e in #(
-+  e) case $CCACHE in
-   [\\/]* | ?:[\\/]*)
-   ac_cv_path_CCACHE="$CCACHE" # Let the user override the test with a path.
-   ;;
-@@ -52422,11 +55135,15 @@ else
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-     for ac_exec_ext in '' $ac_executable_extensions; do
--  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
--    ac_cv_path_CCACHE="$as_dir/$ac_word$ac_exec_ext"
--    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-+  if as_fn_executable_p "$as_dir$ac_word$ac_exec_ext"; then
-+    ac_cv_path_CCACHE="$as_dir$ac_word$ac_exec_ext"
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: found $as_dir$ac_word$ac_exec_ext" >&5
-     break 2
-   fi
- done
-@@ -52434,15 +55151,16 @@ done
- IFS=$as_save_IFS
- 
-   ;;
-+esac ;;
- esac
- fi
- CCACHE=$ac_cv_path_CCACHE
- if test -n "$CCACHE"; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
--$as_echo "$CCACHE" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $CCACHE" >&5
-+printf "%s\n" "$CCACHE" >&6; }
- else
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
- fi
- 
- 
-@@ -52451,17 +55169,17 @@ fi
-         fi
-       else
-         # Otherwise we believe it is a complete path. Use it as it is.
--        { $as_echo "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CCACHE=$tool_specified" >&5
--$as_echo "$as_me: Will use user supplied tool CCACHE=$tool_specified" >&6;}
--        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for CCACHE" >&5
--$as_echo_n "checking for CCACHE... " >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: Will use user supplied tool CCACHE=$tool_specified" >&5
-+printf "%s\n" "$as_me: Will use user supplied tool CCACHE=$tool_specified" >&6;}
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking for CCACHE" >&5
-+printf %s "checking for CCACHE... " >&6; }
-         if test ! -x "$tool_specified"; then
--          { $as_echo "$as_me:${as_lineno-$LINENO}: result: not found" >&5
--$as_echo "not found" >&6; }
-+          { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: not found" >&5
-+printf "%s\n" "not found" >&6; }
-           as_fn_error $? "User supplied tool CCACHE=$tool_specified does not exist or is not executable" "$LINENO" 5
-         fi
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
--$as_echo "$tool_specified" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $tool_specified" >&5
-+printf "%s\n" "$tool_specified" >&6; }
-       fi
-     fi
-   fi
-@@ -52476,21 +55194,22 @@ $as_echo "$tool_specified" >&6; }
-     CCACHE_STATUS="enabled"
-     PATH="$OLD_PATH"
-   elif test "x$enable_ccache" = xno; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, explicitly disabled" >&5
--$as_echo "no, explicitly disabled" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, explicitly disabled" >&5
-+printf "%s\n" "no, explicitly disabled" >&6; }
-   elif test "x$enable_ccache" = x; then
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
--$as_echo "no" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no" >&5
-+printf "%s\n" "no" >&6; }
-   else
--    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
--$as_echo "unknown" >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: unknown" >&5
-+printf "%s\n" "unknown" >&6; }
-     as_fn_error $? "--enable-ccache does not accept any parameters" "$LINENO" 5
-   fi
- 
- 
- 
- # Check whether --with-ccache-dir was given.
--if test "${with_ccache_dir+set}" = set; then :
-+if test ${with_ccache_dir+y}
-+then :
-   withval=$with_ccache_dir;
- fi
- 
-@@ -52500,8 +55219,8 @@ fi
-     # with other users. Thus change the umask.
-     SET_CCACHE_DIR="CCACHE_DIR=$with_ccache_dir CCACHE_UMASK=002"
-     if test "x$CCACHE" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: --with-ccache-dir has no meaning when ccache is not enabled" >&5
--$as_echo "$as_me: WARNING: --with-ccache-dir has no meaning when ccache is not enabled" >&2;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: --with-ccache-dir has no meaning when ccache is not enabled" >&5
-+printf "%s\n" "$as_me: WARNING: --with-ccache-dir has no meaning when ccache is not enabled" >&2;}
-     fi
-   fi
- 
-@@ -52510,45 +55229,47 @@ $as_echo "$as_me: WARNING: --with-ccache-dir has no meaning when ccache is not e
-   if test "x$CCACHE" != x; then
-     # Only use ccache if it is 3.1.4 or later, which supports
-     # precompiled headers.
--    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if ccache supports precompiled headers" >&5
--$as_echo_n "checking if ccache supports precompiled headers... " >&6; }
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if ccache supports precompiled headers" >&5
-+printf %s "checking if ccache supports precompiled headers... " >&6; }
-     HAS_GOOD_CCACHE=`($CCACHE --version | head -n 1 | grep -E 3.1.[456789]) 2> /dev/null`
-     if test "x$HAS_GOOD_CCACHE" = x; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, disabling ccache" >&5
--$as_echo "no, disabling ccache" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, disabling ccache" >&5
-+printf "%s\n" "no, disabling ccache" >&6; }
-       CCACHE=
-       CCACHE_STATUS="disabled"
-     else
--      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
--      { $as_echo "$as_me:${as_lineno-$LINENO}: checking if C-compiler supports ccache precompiled headers" >&5
--$as_echo_n "checking if C-compiler supports ccache precompiled headers... " >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if C-compiler supports ccache precompiled headers" >&5
-+printf %s "checking if C-compiler supports ccache precompiled headers... " >&6; }
-       PUSHED_FLAGS="$CXXFLAGS"
-       CXXFLAGS="-fpch-preprocess $CXXFLAGS"
-       cat confdefs.h - <<_ACEOF >conftest.$ac_ext
- /* end confdefs.h.  */
- 
- int
--main ()
-+main (void)
- {
- 
-   ;
-   return 0;
- }
- _ACEOF
--if ac_fn_cxx_try_compile "$LINENO"; then :
-+if ac_fn_cxx_try_compile "$LINENO"
-+then :
-   CC_KNOWS_CCACHE_TRICK=yes
--else
--  CC_KNOWS_CCACHE_TRICK=no
-+else case e in #(
-+  e) CC_KNOWS_CCACHE_TRICK=no ;;
-+esac
- fi
--rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-+rm -f core conftest.err conftest.$ac_objext conftest.beam conftest.$ac_ext
-       CXXFLAGS="$PUSHED_FLAGS"
-       if test "x$CC_KNOWS_CCACHE_TRICK" = xyes; then
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
--$as_echo "yes" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: yes" >&5
-+printf "%s\n" "yes" >&6; }
-       else
--        { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, disabling ccaching of precompiled headers" >&5
--$as_echo "no, disabling ccaching of precompiled headers" >&6; }
-+        { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: no, disabling ccaching of precompiled headers" >&5
-+printf "%s\n" "no, disabling ccaching of precompiled headers" >&6; }
-         CCACHE=
-         CCACHE_STATUS="disabled"
-       fi
-@@ -52590,13 +55311,13 @@ $as_echo "no, disabling ccaching of precompiled headers" >&6; }
-   if test "x$CONFIGURE_OVERRIDDEN_VARIABLES" != x; then
-     # Replace the separating ! with spaces before presenting for end user.
-     unknown_variables=${CONFIGURE_OVERRIDDEN_VARIABLES//!/ }
--    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: The following variables might be unknown to configure: $unknown_variables" >&5
--$as_echo "$as_me: WARNING: The following variables might be unknown to configure: $unknown_variables" >&2;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: The following variables might be unknown to configure: $unknown_variables" >&5
-+printf "%s\n" "$as_me: WARNING: The following variables might be unknown to configure: $unknown_variables" >&2;}
-   fi
- 
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if build directory is on local disk" >&5
--$as_echo_n "checking if build directory is on local disk... " >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: checking if build directory is on local disk" >&5
-+printf %s "checking if build directory is on local disk... " >&6; }
- 
-   # df -l lists only local disks; if the given directory is not found then
-   # a non-zero exit code is given
-@@ -52621,8 +55342,8 @@ $as_echo_n "checking if build directory is on local disk... " >&6; }
-     fi
-   fi
- 
--  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_DIR_IS_LOCAL" >&5
--$as_echo "$OUTPUT_DIR_IS_LOCAL" >&6; }
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: result: $OUTPUT_DIR_IS_LOCAL" >&5
-+printf "%s\n" "$OUTPUT_DIR_IS_LOCAL" >&6; }
- 
- 
- 
-@@ -52656,8 +55377,8 @@ cat >confcache <<\_ACEOF
- # config.status only pays attention to the cache file if you give it
- # the --recheck option to rerun configure.
- #
--# `ac_cv_env_foo' variables (set or unset) will be overridden when
--# loading this file, other *unset* `ac_cv_foo' will be assigned the
-+# 'ac_cv_env_foo' variables (set or unset) will be overridden when
-+# loading this file, other *unset* 'ac_cv_foo' will be assigned the
- # following values.
- 
- _ACEOF
-@@ -52673,8 +55394,8 @@ _ACEOF
-     case $ac_val in #(
-     *${as_nl}*)
-       case $ac_var in #(
--      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
--$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-+      *_cv_*) { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
-+printf "%s\n" "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-       esac
-       case $ac_var in #(
-       _ | IFS | as_nl) ;; #(
-@@ -52687,14 +55408,14 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-   (set) 2>&1 |
-     case $as_nl`(ac_space=' '; set) 2>&1` in #(
-     *${as_nl}ac_space=\ *)
--      # `set' does not quote correctly, so add quotes: double-quote
-+      # 'set' does not quote correctly, so add quotes: double-quote
-       # substitution turns \\\\ into \\, and sed turns \\ into \.
-       sed -n \
- 	"s/'/'\\\\''/g;
- 	  s/^\\([_$as_cr_alnum]*_cv_[_$as_cr_alnum]*\\)=\\(.*\\)/\\1='\\2'/p"
-       ;; #(
-     *)
--      # `set' quotes correctly as required by POSIX, so do not add quotes.
-+      # 'set' quotes correctly as required by POSIX, so do not add quotes.
-       sed -n "/^[_$as_cr_alnum]*_cv_[_$as_cr_alnum]*=/p"
-       ;;
-     esac |
-@@ -52704,15 +55425,15 @@ $as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
-      /^ac_cv_env_/b end
-      t clear
-      :clear
--     s/^\([^=]*\)=\(.*[{}].*\)$/test "${\1+set}" = set || &/
-+     s/^\([^=]*\)=\(.*[{}].*\)$/test ${\1+y} || &/
-      t end
-      s/^\([^=]*\)=\(.*\)$/\1=${\1=\2}/
-      :end' >>confcache
- if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
-   if test -w "$cache_file"; then
-     if test "x$cache_file" != "x/dev/null"; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
--$as_echo "$as_me: updating cache $cache_file" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
-+printf "%s\n" "$as_me: updating cache $cache_file" >&6;}
-       if test ! -f "$cache_file" || test -h "$cache_file"; then
- 	cat confcache >"$cache_file"
-       else
-@@ -52726,8 +55447,8 @@ $as_echo "$as_me: updating cache $cache_file" >&6;}
-       fi
-     fi
-   else
--    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
--$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
-+    { printf "%s\n" "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
-+printf "%s\n" "$as_me: not updating unwritable cache $cache_file" >&6;}
-   fi
- fi
- rm -f confcache
-@@ -52744,7 +55465,7 @@ U=
- for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
-   # 1. Remove the extension, and $U if already installed.
-   ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
--  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
-+  ac_i=`printf "%s\n" "$ac_i" | sed "$ac_script"`
-   # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
-   #    will be set to the directory where LIBOBJS objects are built.
-   as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
-@@ -52760,8 +55481,8 @@ LTLIBOBJS=$ac_ltlibobjs
- ac_write_fail=0
- ac_clean_files_save=$ac_clean_files
- ac_clean_files="$ac_clean_files $CONFIG_STATUS"
--{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
--$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
-+{ printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
-+printf "%s\n" "$as_me: creating $CONFIG_STATUS" >&6;}
- as_write_fail=0
- cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
- #! $SHELL
-@@ -52784,63 +55505,65 @@ cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
- 
- # Be more Bourne compatible
- DUALCASE=1; export DUALCASE # for MKS sh
--if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
-+if test ${ZSH_VERSION+y} && (emulate sh) >/dev/null 2>&1
-+then :
-   emulate sh
-   NULLCMD=:
-   # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
-   # is contrary to our usage.  Disable this feature.
-   alias -g '${1+"$@"}'='"$@"'
-   setopt NO_GLOB_SUBST
--else
--  case `(set -o) 2>/dev/null` in #(
-+else case e in #(
-+  e) case `(set -o) 2>/dev/null` in #(
-   *posix*) :
-     set -o posix ;; #(
-   *) :
-      ;;
-+esac ;;
- esac
- fi
- 
- 
-+
-+# Reset variables that may have inherited troublesome values from
-+# the environment.
-+
-+# IFS needs to be set, to space, tab, and newline, in precisely that order.
-+# (If _AS_PATH_WALK were called with IFS unset, it would have the
-+# side effect of setting IFS to empty, thus disabling word splitting.)
-+# Quoting is to prevent editors from complaining about space-tab.
- as_nl='
- '
- export as_nl
--# Printing a long string crashes Solaris 7 /usr/bin/printf.
--as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
--as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
--as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
--# Prefer a ksh shell builtin over an external printf program on Solaris,
--# but without wasting forks for bash or zsh.
--if test -z "$BASH_VERSION$ZSH_VERSION" \
--    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
--  as_echo='print -r --'
--  as_echo_n='print -rn --'
--elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
--  as_echo='printf %s\n'
--  as_echo_n='printf %s'
--else
--  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
--    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
--    as_echo_n='/usr/ucb/echo -n'
--  else
--    as_echo_body='eval expr "X$1" : "X\\(.*\\)"'
--    as_echo_n_body='eval
--      arg=$1;
--      case $arg in #(
--      *"$as_nl"*)
--	expr "X$arg" : "X\\(.*\\)$as_nl";
--	arg=`expr "X$arg" : ".*$as_nl\\(.*\\)"`;;
--      esac;
--      expr "X$arg" : "X\\(.*\\)" | tr -d "$as_nl"
--    '
--    export as_echo_n_body
--    as_echo_n='sh -c $as_echo_n_body as_echo'
--  fi
--  export as_echo_body
--  as_echo='sh -c $as_echo_body as_echo'
--fi
-+IFS=" ""	$as_nl"
-+
-+PS1='$ '
-+PS2='> '
-+PS4='+ '
-+
-+# Ensure predictable behavior from utilities with locale-dependent output.
-+LC_ALL=C
-+export LC_ALL
-+LANGUAGE=C
-+export LANGUAGE
-+
-+# We cannot yet rely on "unset" to work, but we need these variables
-+# to be unset--not just set to an empty or harmless value--now, to
-+# avoid bugs in old shells (e.g. pre-3.0 UWIN ksh).  This construct
-+# also avoids known problems related to "unset" and subshell syntax
-+# in other old shells (e.g. bash 2.01 and pdksh 5.2.14).
-+for as_var in BASH_ENV ENV MAIL MAILPATH CDPATH
-+do eval test \${$as_var+y} \
-+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
-+done
-+
-+# Ensure that fds 0, 1, and 2 are open.
-+if (exec 3>&0) 2>/dev/null; then :; else exec 0</dev/null; fi
-+if (exec 3>&1) 2>/dev/null; then :; else exec 1>/dev/null; fi
-+if (exec 3>&2)            ; then :; else exec 2>/dev/null; fi
- 
- # The user is always right.
--if test "${PATH_SEPARATOR+set}" != set; then
-+if ${PATH_SEPARATOR+false} :; then
-   PATH_SEPARATOR=:
-   (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
-     (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
-@@ -52849,13 +55572,6 @@ if test "${PATH_SEPARATOR+set}" != set; then
- fi
- 
- 
--# IFS
--# We need space, tab and new line, in precisely that order.  Quoting is
--# there to prevent editors from complaining about space-tab.
--# (If _AS_PATH_WALK were called with IFS unset, it would disable word
--# splitting by setting IFS to empty value.)
--IFS=" ""	$as_nl"
--
- # Find who we are.  Look in the path if we contain no directory separator.
- as_myself=
- case $0 in #((
-@@ -52864,43 +55580,27 @@ case $0 in #((
- for as_dir in $PATH
- do
-   IFS=$as_save_IFS
--  test -z "$as_dir" && as_dir=.
--    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
-+  case $as_dir in #(((
-+    '') as_dir=./ ;;
-+    */) ;;
-+    *) as_dir=$as_dir/ ;;
-+  esac
-+    test -r "$as_dir$0" && as_myself=$as_dir$0 && break
-   done
- IFS=$as_save_IFS
- 
-      ;;
- esac
--# We did not find ourselves, most probably we were run as `sh COMMAND'
-+# We did not find ourselves, most probably we were run as 'sh COMMAND'
- # in which case we are not to be found in the path.
- if test "x$as_myself" = x; then
-   as_myself=$0
- fi
- if test ! -f "$as_myself"; then
--  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-+  printf "%s\n" "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
-   exit 1
- fi
- 
--# Unset variables that we do not need and which cause bugs (e.g. in
--# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
--# suppresses any "Segmentation fault" message there.  '((' could
--# trigger a bug in pdksh 5.2.14.
--for as_var in BASH_ENV ENV MAIL MAILPATH
--do eval test x\${$as_var+set} = xset \
--  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
--done
--PS1='$ '
--PS2='> '
--PS4='+ '
--
--# NLS nuisances.
--LC_ALL=C
--export LC_ALL
--LANGUAGE=C
--export LANGUAGE
--
--# CDPATH.
--(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
- 
- 
- # as_fn_error STATUS ERROR [LINENO LOG_FD]
-@@ -52913,9 +55613,9 @@ as_fn_error ()
-   as_status=$1; test $as_status -eq 0 && as_status=1
-   if test "$4"; then
-     as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
--    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-+    printf "%s\n" "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
-   fi
--  $as_echo "$as_me: error: $2" >&2
-+  printf "%s\n" "$as_me: error: $2" >&2
-   as_fn_exit $as_status
- } # as_fn_error
- 
-@@ -52946,22 +55646,25 @@ as_fn_unset ()
-   { eval $1=; unset $1;}
- }
- as_unset=as_fn_unset
-+
- # as_fn_append VAR VALUE
- # ----------------------
- # Append the text in VALUE to the end of the definition contained in VAR. Take
- # advantage of any shell optimizations that allow amortized linear growth over
- # repeated appends, instead of the typical quadratic growth present in naive
- # implementations.
--if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
-+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null
-+then :
-   eval 'as_fn_append ()
-   {
-     eval $1+=\$2
-   }'
--else
--  as_fn_append ()
-+else case e in #(
-+  e) as_fn_append ()
-   {
-     eval $1=\$$1\$2
--  }
-+  } ;;
-+esac
- fi # as_fn_append
- 
- # as_fn_arith ARG...
-@@ -52969,16 +55672,18 @@ fi # as_fn_append
- # Perform arithmetic evaluation on the ARGs, and store the result in the
- # global $as_val. Take advantage of shells that can avoid forks. The arguments
- # must be portable across $(()) and expr.
--if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
-+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null
-+then :
-   eval 'as_fn_arith ()
-   {
-     as_val=$(( $* ))
-   }'
--else
--  as_fn_arith ()
-+else case e in #(
-+  e) as_fn_arith ()
-   {
-     as_val=`expr "$@" || test $? -eq 1`
--  }
-+  } ;;
-+esac
- fi # as_fn_arith
- 
- 
-@@ -53005,7 +55710,7 @@ as_me=`$as_basename -- "$0" ||
- $as_expr X/"$0" : '.*/\([^/][^/]*\)/*$' \| \
- 	 X"$0" : 'X\(//\)$' \| \
- 	 X"$0" : 'X\(/\)' \| . 2>/dev/null ||
--$as_echo X/"$0" |
-+printf "%s\n" X/"$0" |
-     sed '/^.*\/\([^/][^/]*\)\/*$/{
- 	    s//\1/
- 	    q
-@@ -53027,6 +55732,10 @@ as_cr_Letters=$as_cr_letters$as_cr_LETTERS
- as_cr_digits='0123456789'
- as_cr_alnum=$as_cr_Letters$as_cr_digits
- 
-+
-+# Determine whether it's possible to make 'echo' print without a newline.
-+# These variables are no longer used directly by Autoconf, but are AC_SUBSTed
-+# for compatibility with existing Makefiles.
- ECHO_C= ECHO_N= ECHO_T=
- case `echo -n x` in #(((((
- -n*)
-@@ -53040,6 +55749,12 @@ case `echo -n x` in #(((((
-   ECHO_N='-n';;
- esac
- 
-+# For backward compatibility with old third-party macros, we provide
-+# the shell variables $as_echo and $as_echo_n.  New code should use
-+# AS_ECHO(["message"]) and AS_ECHO_N(["message"]), respectively.
-+as_echo='printf %s\n'
-+as_echo_n='printf %s'
-+
- rm -f conf$$ conf$$.exe conf$$.file
- if test -d conf$$.dir; then
-   rm -f conf$$.dir/conf$$.file
-@@ -53051,9 +55766,9 @@ if (echo >conf$$.file) 2>/dev/null; then
-   if ln -s conf$$.file conf$$ 2>/dev/null; then
-     as_ln_s='ln -s'
-     # ... but there are two gotchas:
--    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
--    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
--    # In both cases, we have to default to `cp -pR'.
-+    # 1) On MSYS, both 'ln -s file dir' and 'ln file dir' fail.
-+    # 2) DJGPP < 2.04 has no symlinks; 'ln -s' creates a wrapper executable.
-+    # In both cases, we have to default to 'cp -pR'.
-     ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
-       as_ln_s='cp -pR'
-   elif ln conf$$.file conf$$ 2>/dev/null; then
-@@ -53081,7 +55796,7 @@ as_fn_mkdir_p ()
-     as_dirs=
-     while :; do
-       case $as_dir in #(
--      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-+      *\'*) as_qdir=`printf "%s\n" "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
-       *) as_qdir=$as_dir;;
-       esac
-       as_dirs="'$as_qdir' $as_dirs"
-@@ -53090,7 +55805,7 @@ $as_expr X"$as_dir" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
- 	 X"$as_dir" : 'X\(//\)[^/]' \| \
- 	 X"$as_dir" : 'X\(//\)$' \| \
- 	 X"$as_dir" : 'X\(/\)' \| . 2>/dev/null ||
--$as_echo X"$as_dir" |
-+printf "%s\n" X"$as_dir" |
-     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
- 	    s//\1/
- 	    q
-@@ -53134,10 +55849,12 @@ as_test_x='test -x'
- as_executable_p=as_fn_executable_p
- 
- # Sed expression to map a string onto a valid CPP name.
--as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g'"
-+as_sed_cpp="y%*$as_cr_letters%P$as_cr_LETTERS%;s%[^_$as_cr_alnum]%_%g"
-+as_tr_cpp="eval sed '$as_sed_cpp'" # deprecated
- 
- # Sed expression to map a string onto a valid variable name.
--as_tr_sh="eval sed 'y%*+%pp%;s%[^_$as_cr_alnum]%_%g'"
-+as_sed_sh="y%*+%pp%;s%[^_$as_cr_alnum]%_%g"
-+as_tr_sh="eval sed '$as_sed_sh'" # deprecated
- 
- 
- exec 6>&1
-@@ -53153,7 +55870,7 @@ cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
- # values after options handling.
- ac_log="
- This file was extended by OpenJDK $as_me jdk8, which was
--generated by GNU Autoconf 2.69.  Invocation command line was
-+generated by GNU Autoconf 2.72.  Invocation command line was
- 
-   CONFIG_FILES    = $CONFIG_FILES
-   CONFIG_HEADERS  = $CONFIG_HEADERS
-@@ -53184,7 +55901,7 @@ _ACEOF
- 
- cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
- ac_cs_usage="\
--\`$as_me' instantiates files and other configuration actions
-+'$as_me' instantiates files and other configuration actions
- from templates according to the current configuration.  Unless the files
- and actions are specified as TAGs, all are instantiated by default.
- 
-@@ -53212,14 +55929,16 @@ Report bugs to <build-dev@openjdk.java.net>.
- OpenJDK home page: <http://openjdk.java.net>."
- 
- _ACEOF
-+ac_cs_config=`printf "%s\n" "$ac_configure_args" | sed "$ac_safe_unquote"`
-+ac_cs_config_escaped=`printf "%s\n" "$ac_cs_config" | sed "s/^ //; s/'/'\\\\\\\\''/g"`
- cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
--ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/[\\""\`\$]/\\\\&/g'`"
-+ac_cs_config='$ac_cs_config_escaped'
- ac_cs_version="\\
- OpenJDK config.status jdk8
--configured by $0, generated by GNU Autoconf 2.69,
-+configured by $0, generated by GNU Autoconf 2.72,
-   with options \\"\$ac_cs_config\\"
- 
--Copyright (C) 2012 Free Software Foundation, Inc.
-+Copyright (C) 2023 Free Software Foundation, Inc.
- This config.status script is free software; the Free Software Foundation
- gives unlimited permission to copy, distribute and modify it."
- 
-@@ -53257,15 +55976,15 @@ do
-   -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
-     ac_cs_recheck=: ;;
-   --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
--    $as_echo "$ac_cs_version"; exit ;;
-+    printf "%s\n" "$ac_cs_version"; exit ;;
-   --config | --confi | --conf | --con | --co | --c )
--    $as_echo "$ac_cs_config"; exit ;;
-+    printf "%s\n" "$ac_cs_config"; exit ;;
-   --debug | --debu | --deb | --de | --d | -d )
-     debug=: ;;
-   --file | --fil | --fi | --f )
-     $ac_shift
-     case $ac_optarg in
--    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
-+    *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
-     '') as_fn_error $? "missing file argument" ;;
-     esac
-     as_fn_append CONFIG_FILES " '$ac_optarg'"
-@@ -53273,23 +55992,23 @@ do
-   --header | --heade | --head | --hea )
-     $ac_shift
-     case $ac_optarg in
--    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
-+    *\'*) ac_optarg=`printf "%s\n" "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
-     esac
-     as_fn_append CONFIG_HEADERS " '$ac_optarg'"
-     ac_need_defaults=false;;
-   --he | --h)
-     # Conflict between --help and --header
--    as_fn_error $? "ambiguous option: \`$1'
--Try \`$0 --help' for more information.";;
-+    as_fn_error $? "ambiguous option: '$1'
-+Try '$0 --help' for more information.";;
-   --help | --hel | -h )
--    $as_echo "$ac_cs_usage"; exit ;;
-+    printf "%s\n" "$ac_cs_usage"; exit ;;
-   -q | -quiet | --quiet | --quie | --qui | --qu | --q \
-   | -silent | --silent | --silen | --sile | --sil | --si | --s)
-     ac_cs_silent=: ;;
- 
-   # This is an error.
--  -*) as_fn_error $? "unrecognized option: \`$1'
--Try \`$0 --help' for more information." ;;
-+  -*) as_fn_error $? "unrecognized option: '$1'
-+Try '$0 --help' for more information." ;;
- 
-   *) as_fn_append ac_config_targets " $1"
-      ac_need_defaults=false ;;
-@@ -53310,7 +56029,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
- if \$ac_cs_recheck; then
-   set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
-   shift
--  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
-+  \printf "%s\n" "running CONFIG_SHELL=$SHELL \$*" >&6
-   CONFIG_SHELL='$SHELL'
-   export CONFIG_SHELL
-   exec "\$@"
-@@ -53324,7 +56043,7 @@ exec 5>>config.log
-   sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
- ## Running $as_me. ##
- _ASBOX
--  $as_echo "$ac_log"
-+  printf "%s\n" "$ac_log"
- } >&5
- 
- _ACEOF
-@@ -53345,7 +56064,7 @@ do
-     "$OUTPUT_ROOT/spec.sh") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/spec.sh:$AUTOCONF_DIR/spec.sh.in" ;;
-     "$OUTPUT_ROOT/Makefile") CONFIG_FILES="$CONFIG_FILES $OUTPUT_ROOT/Makefile:$AUTOCONF_DIR/Makefile.in" ;;
- 
--  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
-+  *) as_fn_error $? "invalid argument: '$ac_config_target'" "$LINENO" 5;;
-   esac
- done
- 
-@@ -53355,8 +56074,8 @@ done
- # We use the long form for the default assignment because of an extremely
- # bizarre bug on SunOS 4.1.3.
- if $ac_need_defaults; then
--  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
--  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
-+  test ${CONFIG_FILES+y} || CONFIG_FILES=$config_files
-+  test ${CONFIG_HEADERS+y} || CONFIG_HEADERS=$config_headers
- fi
- 
- # Have a temporary directory for convenience.  Make it in the build tree
-@@ -53364,7 +56083,7 @@ fi
- # creating and moving files from /tmp can sometimes cause problems.
- # Hook for its removal unless debugging.
- # Note that there is a small window in which the directory will not be cleaned:
--# after its creation but before its name has been assigned to `$tmp'.
-+# after its creation but before its name has been assigned to '$tmp'.
- $debug ||
- {
-   tmp= ac_tmp=
-@@ -53388,7 +56107,7 @@ ac_tmp=$tmp
- 
- # Set up the scripts for CONFIG_FILES section.
- # No need to generate them if there are no CONFIG_FILES.
--# This happens for instance with `./config.status config.h'.
-+# This happens for instance with './config.status config.h'.
- if test -n "$CONFIG_FILES"; then
- 
- 
-@@ -53546,13 +56265,13 @@ fi # test -n "$CONFIG_FILES"
- 
- # Set up the scripts for CONFIG_HEADERS section.
- # No need to generate them if there are no CONFIG_HEADERS.
--# This happens for instance with `./config.status Makefile'.
-+# This happens for instance with './config.status Makefile'.
- if test -n "$CONFIG_HEADERS"; then
- cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
- BEGIN {
- _ACEOF
- 
--# Transform confdefs.h into an awk script `defines.awk', embedded as
-+# Transform confdefs.h into an awk script 'defines.awk', embedded as
- # here-document in config.status, that substitutes the proper values into
- # config.h.in to produce config.h.
- 
-@@ -53662,7 +56381,7 @@ do
-   esac
-   case $ac_mode$ac_tag in
-   :[FHL]*:*);;
--  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
-+  :L* | :C*:*) as_fn_error $? "invalid tag '$ac_tag'" "$LINENO" 5;;
-   :[FH]-) ac_tag=-:-;;
-   :[FH]*) ac_tag=$ac_tag:$ac_tag.in;;
-   esac
-@@ -53684,33 +56403,33 @@ do
-       -) ac_f="$ac_tmp/stdin";;
-       *) # Look for the file first in the build tree, then in the source tree
- 	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
--	 # because $ac_f cannot contain `:'.
-+	 # because $ac_f cannot contain ':'.
- 	 test -f "$ac_f" ||
- 	   case $ac_f in
- 	   [\\/$]*) false;;
- 	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
- 	   esac ||
--	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
-+	   as_fn_error 1 "cannot find input file: '$ac_f'" "$LINENO" 5;;
-       esac
--      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
-+      case $ac_f in *\'*) ac_f=`printf "%s\n" "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
-       as_fn_append ac_file_inputs " '$ac_f'"
-     done
- 
--    # Let's still pretend it is `configure' which instantiates (i.e., don't
-+    # Let's still pretend it is 'configure' which instantiates (i.e., don't
-     # use $as_me), people would be surprised to read:
-     #    /* config.h.  Generated by config.status.  */
-     configure_input='Generated from '`
--	  $as_echo "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
-+	  printf "%s\n" "$*" | sed 's|^[^:]*/||;s|:[^:]*/|, |g'
- 	`' by configure.'
-     if test x"$ac_file" != x-; then
-       configure_input="$ac_file.  $configure_input"
--      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
--$as_echo "$as_me: creating $ac_file" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
-+printf "%s\n" "$as_me: creating $ac_file" >&6;}
-     fi
-     # Neutralize special characters interpreted by sed in replacement strings.
-     case $configure_input in #(
-     *\&* | *\|* | *\\* )
--       ac_sed_conf_input=`$as_echo "$configure_input" |
-+       ac_sed_conf_input=`printf "%s\n" "$configure_input" |
-        sed 's/[\\\\&|]/\\\\&/g'`;; #(
-     *) ac_sed_conf_input=$configure_input;;
-     esac
-@@ -53727,7 +56446,7 @@ $as_expr X"$ac_file" : 'X\(.*[^/]\)//*[^/][^/]*/*$' \| \
- 	 X"$ac_file" : 'X\(//\)[^/]' \| \
- 	 X"$ac_file" : 'X\(//\)$' \| \
- 	 X"$ac_file" : 'X\(/\)' \| . 2>/dev/null ||
--$as_echo X"$ac_file" |
-+printf "%s\n" X"$ac_file" |
-     sed '/^X\(.*[^/]\)\/\/*[^/][^/]*\/*$/{
- 	    s//\1/
- 	    q
-@@ -53751,9 +56470,9 @@ $as_echo X"$ac_file" |
- case "$ac_dir" in
- .) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
- *)
--  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.[\\/]||'`
-+  ac_dir_suffix=/`printf "%s\n" "$ac_dir" | sed 's|^\.[\\/]||'`
-   # A ".." for each directory in $ac_dir_suffix.
--  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-+  ac_top_builddir_sub=`printf "%s\n" "$ac_dir_suffix" | sed 's|/[^\\/]*|/..|g;s|/||'`
-   case $ac_top_builddir_sub in
-   "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
-   *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
-@@ -53806,8 +56525,8 @@ ac_sed_dataroot='
- case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
- *datarootdir*) ac_datarootdir_seen=yes;;
- *@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
--  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
--$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
-+printf "%s\n" "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
- _ACEOF
- cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-   ac_datarootdir_hack='
-@@ -53820,7 +56539,7 @@ cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
- esac
- _ACEOF
- 
--# Neutralize VPATH when `$srcdir' = `.'.
-+# Neutralize VPATH when '$srcdir' = '.'.
- # Shell code in configure.ac might set extrasub.
- # FIXME: do we really want to maintain this feature?
- cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
-@@ -53849,9 +56568,9 @@ test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
-   { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
-   { ac_out=`sed -n '/^[	 ]*datarootdir[	 ]*:*=/p' \
-       "$ac_tmp/out"`; test -z "$ac_out"; } &&
--  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable 'datarootdir'
- which seems to be undefined.  Please make sure it is defined" >&5
--$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
-+printf "%s\n" "$as_me: WARNING: $ac_file contains a reference to the variable 'datarootdir'
- which seems to be undefined.  Please make sure it is defined" >&2;}
- 
-   rm -f "$ac_tmp/stdin"
-@@ -53867,20 +56586,20 @@ which seems to be undefined.  Please make sure it is defined" >&2;}
-   #
-   if test x"$ac_file" != x-; then
-     {
--      $as_echo "/* $configure_input  */" \
-+      printf "%s\n" "/* $configure_input  */" >&1 \
-       && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
-     } >"$ac_tmp/config.h" \
-       || as_fn_error $? "could not create $ac_file" "$LINENO" 5
-     if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
--      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
--$as_echo "$as_me: $ac_file is unchanged" >&6;}
-+      { printf "%s\n" "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
-+printf "%s\n" "$as_me: $ac_file is unchanged" >&6;}
-     else
-       rm -f "$ac_file"
-       mv "$ac_tmp/config.h" "$ac_file" \
- 	|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
-     fi
-   else
--    $as_echo "/* $configure_input  */" \
-+    printf "%s\n" "/* $configure_input  */" >&1 \
-       && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
-       || as_fn_error $? "could not create -" "$LINENO" 5
-   fi
-@@ -53921,8 +56640,8 @@ if test "$no_create" != yes; then
-   $ac_cs_success || as_fn_exit 1
- fi
- if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
--  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
--$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
-+  { printf "%s\n" "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
-+printf "%s\n" "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
- fi
- 
- 
-@@ -54043,3 +56762,4 @@ fi
-     fi
-   fi
- 
-+
 diff --git a/common/autoconf/jdk-options.m4 b/common/autoconf/jdk-options.m4
 index 18ba585209..e46cb823ef 100644
 --- a/common/autoconf/jdk-options.m4

From 808fd47b9bc9d6c5ee0d5791ad519200a4507103 Mon Sep 17 00:00:00 2001
From: Andrew Leonard <andrew.m.leonard@ibm.com>
Date: Fri, 28 Aug 2026 13:58:56 +0100
Subject: [PATCH 27/27] chore(mirror_cspu): add actions ignore branches patch
 for riscv-port-jdk11u

---
 patches/riscv-port-jdk11u/actions-ignore-branches.patch | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 patches/riscv-port-jdk11u/actions-ignore-branches.patch

diff --git a/patches/riscv-port-jdk11u/actions-ignore-branches.patch b/patches/riscv-port-jdk11u/actions-ignore-branches.patch
new file mode 100644
index 0000000..e69de29