5 files changed, 68 insertions, 43 deletions

diff --git a/api/logic/java/JavaVersion.cpp b/api/logic/java/JavaVersion.cpp
index 84fc48a4..8c1bb430 100644
--- a/api/logic/java/JavaVersion.cpp
+++ b/api/logic/java/JavaVersion.cpp
@@ -6,7 +6,7 @@
 
 JavaVersion & JavaVersion::operator=(const QString & javaVersionString)
 {
-	string = javaVersionString;
+	m_string = javaVersionString;
 
 	auto getCapturedInteger = [](const QRegularExpressionMatch & match, const QString &what) -> int
 	{
@@ -28,12 +28,12 @@ JavaVersion & JavaVersion::operator=(const QString & javaVersionString)
 		pattern = QRegularExpression("(?<major>[0-9]+)([.](?<minor>[0-9]+))?([.](?<security>[0-9]+))?(-(?<prerelease>[a-zA-Z0-9]+))?");
 	}
 
-	auto match = pattern.match(string);
-	parseable = match.hasMatch();
-	major = getCapturedInteger(match, "major");
-	minor = getCapturedInteger(match, "minor");
-	security = getCapturedInteger(match, "security");
-	prerelease = match.captured("prerelease");
+	auto match = pattern.match(m_string);
+	m_parseable = match.hasMatch();
+	m_major = getCapturedInteger(match, "major");
+	m_minor = getCapturedInteger(match, "minor");
+	m_security = getCapturedInteger(match, "security");
+	m_prerelease = match.captured("prerelease");
 	return *this;
 }
 
@@ -44,38 +44,38 @@ JavaVersion::JavaVersion(const QString &rhs)
 
 QString JavaVersion::toString()
 {
-	return string;
+	return m_string;
 }
 
 bool JavaVersion::requiresPermGen()
 {
-	if(parseable)
+	if(m_parseable)
 	{
-		return major < 8;
+		return m_major < 8;
 	}
 	return true;
 }
 
 bool JavaVersion::operator<(const JavaVersion &rhs)
 {
-	if(parseable && rhs.parseable)
+	if(m_parseable && rhs.m_parseable)
 	{
-		if(major < rhs.major)
+		if(m_major < rhs.m_major)
 			return true;
-		if(major > rhs.major)
+		if(m_major > rhs.m_major)
 			return false;
-		if(minor < rhs.minor)
+		if(m_minor < rhs.m_minor)
 			return true;
-		if(minor > rhs.minor)
+		if(m_minor > rhs.m_minor)
 			return false;
-		if(security < rhs.security)
+		if(m_security < rhs.m_security)
 			return true;
-		if(security > rhs.security)
+		if(m_security > rhs.m_security)
 			return false;
 
 		// everything else being equal, consider prerelease status
-		bool thisPre = !prerelease.isEmpty();
-		bool rhsPre = !rhs.prerelease.isEmpty();
+		bool thisPre = !m_prerelease.isEmpty();
+		bool rhsPre = !rhs.m_prerelease.isEmpty();
 		if(thisPre && !rhsPre)
 		{
 			// this is a prerelease and the other one isn't -> lesser
@@ -89,21 +89,21 @@ bool JavaVersion::operator<(const JavaVersion &rhs)
 		else if(thisPre && rhsPre)
 		{
 			// both are prereleases - use natural compare...
-			return Strings::naturalCompare(prerelease, rhs.prerelease, Qt::CaseSensitive) < 0;
+			return Strings::naturalCompare(m_prerelease, rhs.m_prerelease, Qt::CaseSensitive) < 0;
 		}
 		// neither is prerelease, so they are the same -> this cannot be less than rhs
 		return false;
 	}
-	else return Strings::naturalCompare(string, rhs.string, Qt::CaseSensitive) < 0;
+	else return Strings::naturalCompare(m_string, rhs.m_string, Qt::CaseSensitive) < 0;
 }
 
 bool JavaVersion::operator==(const JavaVersion &rhs)
 {
-	if(parseable && rhs.parseable)
+	if(m_parseable && rhs.m_parseable)
 	{
-		return major == rhs.major && minor == rhs.minor && security == rhs.security && prerelease == rhs.prerelease;
+		return m_major == rhs.m_major && m_minor == rhs.m_minor && m_security == rhs.m_security && m_prerelease == rhs.m_prerelease;
 	}
-	return string == rhs.string;
+	return m_string == rhs.m_string;
 }
 
 bool JavaVersion::operator>(const JavaVersion &rhs)
diff --git a/api/logic/java/JavaVersion.h b/api/logic/java/JavaVersion.h
index f9a733d3..deba5654 100644
--- a/api/logic/java/JavaVersion.h
+++ b/api/logic/java/JavaVersion.h
@@ -20,11 +20,23 @@ public:
 
 	QString toString();
 
+	int major()
+	{
+		return m_major;
+	}
+	int minor()
+	{
+		return m_minor;
+	}
+	int security()
+	{
+		return m_security;
+	}
 private:
-	QString string;
-	int major = 0;
-	int minor = 0;
-	int security = 0;
-	bool parseable = false;
-	QString prerelease;
+	QString m_string;
+	int m_major = 0;
+	int m_minor = 0;
+	int m_security = 0;
+	bool m_parseable = false;
+	QString m_prerelease;
 };
diff --git a/api/logic/java/JavaVersion_test.cpp b/api/logic/java/JavaVersion_test.cpp
index 9dae0ba6..e719ffc8 100644
--- a/api/logic/java/JavaVersion_test.cpp
+++ b/api/logic/java/JavaVersion_test.cpp
@@ -34,12 +34,12 @@ slots:
 		QFETCH(QString, prerelease);
 
 		JavaVersion test(string);
-		QCOMPARE(test.string, string);
+		QCOMPARE(test.m_string, string);
 		QCOMPARE(test.toString(), string);
-		QCOMPARE(test.major, major);
-		QCOMPARE(test.minor, minor);
-		QCOMPARE(test.security, security);
-		QCOMPARE(test.prerelease, prerelease);
+		QCOMPARE(test.m_major, major);
+		QCOMPARE(test.m_minor, minor);
+		QCOMPARE(test.m_security, security);
+		QCOMPARE(test.m_prerelease, prerelease);
 	}
 
 	void test_Sort_data()
diff --git a/api/logic/java/launch/CheckJava.cpp b/api/logic/java/launch/CheckJava.cpp
index a4eaa307..41bb6398 100644
--- a/api/logic/java/launch/CheckJava.cpp
+++ b/api/logic/java/launch/CheckJava.cpp
@@ -53,20 +53,25 @@ void CheckJava::executeTask()
 	QFileInfo javaInfo(realJavaPath);
 	qlonglong javaUnixTime = javaInfo.lastModified().toMSecsSinceEpoch();
 	auto storedUnixTime = settings->get("JavaTimestamp").toLongLong();
+	auto storedArchitecture = settings->get("JavaArchitecture").toString();
+	auto storedVersion = settings->get("JavaVersion").toString();
 	m_javaUnixTime = javaUnixTime;
-	// if they are not the same, check!
-	if (javaUnixTime != storedUnixTime)
+	// if timestamps are not the same, or something is missing, check!
+	if (javaUnixTime != storedUnixTime || storedVersion.size() == 0 || storedArchitecture.size() == 0)
 	{
 		m_JavaChecker = std::make_shared<JavaChecker>();
-		QString errorLog;
-		QString version;
 		emit logLine(tr("Checking Java version..."), MessageLevel::MultiMC);
-		connect(m_JavaChecker.get(), &JavaChecker::checkFinished, this,
-				&CheckJava::checkJavaFinished);
+		connect(m_JavaChecker.get(), &JavaChecker::checkFinished, this, &CheckJava::checkJavaFinished);
 		m_JavaChecker->m_path = realJavaPath;
 		m_JavaChecker->performCheck();
 		return;
 	}
+	else
+	{
+		auto verString = instance->settings()->get("JavaVersion").toString();
+		auto archString = instance->settings()->get("JavaArchitecture").toString();
+		printJavaInfo(verString, archString);
+	}
 	emitSucceeded();
 }
 
@@ -83,10 +88,15 @@ void CheckJava::checkJavaFinished(JavaCheckResult result)
 	else
 	{
 		auto instance = m_parent->instance();
-		emit logLine(tr("Java version is %1!\n").arg(result.javaVersion.toString()),
-					 MessageLevel::MultiMC);
+		printJavaInfo(result.javaVersion.toString(), result.mojangPlatform);
 		instance->settings()->set("JavaVersion", result.javaVersion.toString());
+		instance->settings()->set("JavaArchitecture", result.mojangPlatform);
 		instance->settings()->set("JavaTimestamp", m_javaUnixTime);
 		emitSucceeded();
 	}
 }
+
+void CheckJava::printJavaInfo(const QString& version, const QString& architecture)
+{
+	emit logLine(tr("Java is version %1, using %2-bit architecture.\n\n").arg(version, architecture), MessageLevel::MultiMC);
+}
diff --git a/api/logic/java/launch/CheckJava.h b/api/logic/java/launch/CheckJava.h
index b63dd4f4..118da225 100644
--- a/api/logic/java/launch/CheckJava.h
+++ b/api/logic/java/launch/CheckJava.h
@@ -35,6 +35,9 @@ private slots:
 	void checkJavaFinished(JavaCheckResult result);
 
 private:
+	void printJavaInfo(const QString & version, const QString & architecture);
+
+private:
 	QString m_javaPath;
 	qlonglong m_javaUnixTime;
 	JavaCheckerPtr m_JavaChecker;