settings.gradle

   1 import java.nio.file.Paths
   2 import java.nio.file.Files
   3 import java.util.regex.Pattern
   4 import java.util.stream.Collectors
   5
   6 // Poking PATH is used by multiple systems
   7 def envRawPathProperty = System.getenv("PATH")
   8 def envPath = (envRawPathProperty != null ?
   9         Arrays.asList(
  10                 envRawPathProperty.split(Pattern.quote(File.pathSeparator)))
  11                         .stream().<java.nio.file.Path>map({it -> Paths.get(it)})
  12                         .collect(Collectors.toList()) :
  13                         Collections.<java.nio.file.Path>emptyList())
  14
  15 // Do we have Termux in our PATH?
  16 def foundTermuxRoot = false
  17 for (java.nio.file.Path path : envPath) {
  18         def fullPath = path.toAbsolutePath();
  19         if (fullPath.toString().startsWith("/data/data/com.termux/")) {
  20                 foundTermuxRoot = true;
  21         }
  22 }
  23
  24 // Did we find Termux in our PATH?
  25 if ((foundTermuxRoot && System.getProperty("force.termux") == null) ||
  26         Boolean.getBoolean("force.termux")) {
  27         // squirreljmeTermuxCompiler
  28         logger.lifecycle("Appears we are in Termux, kludging compiler build...")
  29
  30         // Enable it
  31         gradle.beforeProject({proj ->
  32                 proj.ext.squirreljmeTermuxCompiler = true
  33         })
  34 }
  35
  36 // Is this Mac OS?
  37 def osName = System.getProperty("os.name")
  38 if (osName.equalsIgnoreCase('Mac OS X')) {
  39         gradle.beforeProject({proj ->
  40                 proj.ext.squirreljmeIsOnMacOs = true
  41         })
  42 }
  43
  44 // If we are on M1 Macs, perform some modifications so that Gradle can compile
  45 // C++ code
  46 def osArch = System.getProperty("os.arch")
  47 if (osName.equalsIgnoreCase('Mac OS X') &&
  48         (osArch.equalsIgnoreCase('aarch64') || osArch.equalsIgnoreCase('arm64') ||
  49         osArch.equalsIgnoreCase('arm64-v8'))) {
  50         logger.warn("Faking x86_64 for M1 Macs...")
  51
  52         gradle.beforeProject({proj ->
  53                 proj.ext.squirreljmeMacOsArmCpp = true
  54         })
  55 }
  56
  57 if (osArch.equalsIgnoreCase("ppc") ||
  58         osArch.equalsIgnoreCase("powerpc") ||
  59         osArch.equalsIgnoreCase("ppc64") ||
  60         osArch.equalsIgnoreCase("ppc64le") ||
  61         osArch.equalsIgnoreCase("riscv") ||
  62         osArch.equalsIgnoreCase("riscv32") ||
  63         osArch.equalsIgnoreCase("riscv64") ||
  64         osArch.equalsIgnoreCase('aarch64') ||
  65         osArch.equalsIgnoreCase('arm64')) {
  66         logger.warn("Faking x86_64 for other architectures...")
  67
  68         gradle.beforeProject({proj ->
  69                 proj.ext.squirreljmeClaimX8664 = true
  70         })
  71 }
  72
  73 // If we have a really high Java version being used then the parameters
  74 // for -source and -target were likely removed, so as such we cannot rely on
  75 // the project being able to be built in such versions.
  76 if (JavaVersion.current() >= JavaVersion.VERSION_HIGHER ||
  77         Boolean.getBoolean("force.ecj")) {
  78         // Emit a warning to indicate that the version is quite new
  79         logger.warn("The current Java version is quite new, " +
  80                 "if Eclipse Java Compiler (ECJ) exists on the system " +
  81                 "then it will be used to compile the modules instead.")
  82
  83         // Does ECJ exist in the system PATH?
  84         def foundEcjBinary = false
  85         for (java.nio.file.Path path : envPath) {
  86                 if (Files.exists(path.resolve("ecj"))) {
  87                         foundEcjBinary = true
  88                 }
  89         }
  90
  91         // If we have the binary, use it
  92         if (foundEcjBinary) {
  93                 logger.lifecycle("Found ECJ binary, using it!")
  94
  95                 gradle.beforeProject({proj ->
  96                         proj.ext.squirreljmeEcjEnabled = true
  97                 })
  98         } else {
  99                 logger.warn("Could not find ECJ, build may fail!")
 100         }
 101 }
 102
 103 // Modules and available platforms
 104 include "modules"
 105 include "emulators"
 106 include "sdk"
 107 include "tools"
 108
 109 // Recursively include all modules
 110 file(rootProject.projectDir.toPath().resolve("modules"))
 111         .eachDir(
 112         { subdir ->
 113                 if (subdir.toPath().resolve("build.gradle").toFile().exists())
 114                 {
 115                         include "modules:" + subdir.name
 116                 }
 117         })
 118
 119 // Recursively include all emulators
 120 file(rootProject.projectDir.toPath().resolve("emulators"))
 121         .eachDir(
 122         { subdir ->
 123                 if (subdir.toPath().resolve("build.gradle").toFile().exists())
 124                 {
 125                         include "emulators:" + subdir.name
 126                 }
 127         })
 128
 129 // Recursively include all tools
 130 file(rootProject.projectDir.toPath().resolve("tools"))
 131         .eachDir(
 132         { subdir ->
 133                 if (subdir.toPath().resolve("build.gradle").toFile().exists())
 134                 {
 135                         include "tools:" + subdir.name
 136                 }
 137         })