Warning system (#189)

* first draft

* take vt.h from mm repo

* Colors

* Fix argument types

* Add argument parser to errorhandler

* Rename ErrorHandler to WarningHandler

* Add -Wno- and more warning types

* header and body in warnings

* Small cleanup

* Replace a bunch of warnings with the new system

Co-authored-by: EllipticEllipsis <EllipticEllipsis@users.noreply.github.com>

* Move stuff around

* Move stuff to header

* Make some more VT macros, new Warning_Build function + macro, ZBackground

* Add remaining warnings

* Add ZResource* param to Warning_Resource

* Add warning help message

* Simplify help message a bit

* Refactor warnings into lots of helper functions

* Fix HANG_INDT in the wild

* Builds now

* Update macros to use bold

* Fix body printing and error colour

* Add -Werror=

* Add warningType to HANDLE_ERROR

* Change some throws into HANDLE_ERROR

* Create init and main maps and write new help printer

* Changed ZTextureAnimation to new w/e

* Typo

* Delete build warnings list file

* Use ERROR in ZResource and ZPath

* Remove extra structs

* Move ifdef into the InitMap, add descriptions

* Actually move into initMap and add descriptions...

* Remove Everything from the WarningType enum

* Make more of the handler arguments const for compatibility

* Fix warning

* Document macros a bit

* Add ImageBackend ERRRORs

* Note on Weverything, rename InvalidData to InvalidExtractedData

* add texture and mesh warnings/errors

* InvalidExtractedData

* Add description for InvalidPNG

* print which warnings are enabled by using debug verbosity

* Fix everything

* Fix some newlines

* Move help to the end, start some documentation

* Remove unnecessary `WarningHandler::`s

* Remove commented code

* Some more documentation

* Make first letters consistenty lowercase, more docs

* Consistently use lowercase, more docs

* Format consistently, more detail in documentation

* Simplify enabled warnings checks

* Rename HANDLE_WARNING_BUILD and add HANDLE_ERROR_PROCESS

* Delete BuildInfo.cpp

* Use PROCESS where possible, bit more documentation

* Add documenation to README, sort when printing help

* Add an example, escalate the rest of the invalids by default

* Format warning names in table

* format readme

* Remove old flags info

* Remove obsolete variables

* Format

* assert.h -> cassert

* Replace some asserts in ZTexture

* Remove test file

* Minor cleanup

* Bit more in the help

* Fix header includes

* Format

* One character in readme

* Update README.md

Co-authored-by: Anghelo Carvajal <angheloalf95@gmail.com>

* Some Morita inspiration

* Convert new errors

* Static warnings/errors

* Merge remote-tracking branch 'upstream/master' into errorlib

* Add explanation for switch control flow

* format

* whooops

* Fix segment warning that doesn't apply now we assume no segment means use VRAM

* Comment out MM in Jenkinsfile

Co-authored-by: Angie <angheloalf95@gmail.com>
Co-authored-by: EllipticEllipsis <EllipticEllipsis@users.noreply.github.com>

1 files changed, 64 insertions, 65 deletions

diff --git a/ZAPD/ZFile.cpp b/ZAPD/ZFile.cpp
index ff57778..b95671b 100644
--- a/ZAPD/ZFile.cpp
+++ b/ZAPD/ZFile.cpp
@@ -13,6 +13,7 @@
 #include "Utils/MemoryStream.h"
 #include "Utils/Path.h"
 #include "Utils/StringHelper.h"
+#include "WarningHandler.h"
 #include "ZAnimation.h"
 #include "ZArray.h"
 #include "ZBackground.h"
@@ -114,8 +115,11 @@ void ZFile::ParseXML(tinyxml2::XMLElement* reader, const std::string& filename)
 		else if (std::string_view(gameStr) == "OOT")
 			Globals::Instance->game = ZGame::OOT_RETAIL;
 		else
-			throw std::runtime_error(
-				StringHelper::Sprintf("Error: Game type %s not supported.", gameStr));
+		{
+			std::string errorHeader =
+				StringHelper::Sprintf("'Game' type '%s' is not supported.", gameStr);
+			HANDLE_ERROR_PROCESS(WarningType::InvalidAttributeValue, errorHeader, "");
+		}
 	}
 
 	if (reader->Attribute("BaseAddress") != nullptr)
@@ -128,16 +132,22 @@ void ZFile::ParseXML(tinyxml2::XMLElement* reader, const std::string& filename)
 		rangeEnd = StringHelper::StrToL(reader->Attribute("RangeEnd"), 16);
 
 	if (rangeStart > rangeEnd)
-		throw std::runtime_error("Error: RangeStart must be before than RangeEnd.");
+		HANDLE_ERROR_PROCESS(
+			WarningType::Always,
+			StringHelper::Sprintf("'RangeStart' 0x%06X must be before 'RangeEnd' 0x%06X",
+		                          rangeStart, rangeEnd),
+			"");
 
 	const char* segmentXml = reader->Attribute("Segment");
 	if (segmentXml != nullptr)
 	{
 		if (!StringHelper::HasOnlyDigits(segmentXml))
 		{
-			throw std::runtime_error(StringHelper::Sprintf(
-				"error: Invalid segment value '%s': must be a decimal between 0 and 15 inclusive",
-				segmentXml));
+			HANDLE_ERROR_PROCESS(WarningType::Always,
+			                     StringHelper::Sprintf("error: Invalid segment value '%s': must be "
+			                                           "a decimal between 0 and 15 inclusive",
+			                                           segmentXml),
+			                     "");
 		}
 
 		segment = StringHelper::StrToL(segmentXml, 10);
@@ -146,16 +156,19 @@ void ZFile::ParseXML(tinyxml2::XMLElement* reader, const std::string& filename)
 			if (segment == 128)
 			{
 #ifdef DEPRECATION_ON
-				fprintf(stderr, "warning: segment 128 is deprecated.\n\tRemove "
-				                "'Segment=\"128\"' from the xml to use virtual addresses\n");
+				HANDLE_WARNING_PROCESS(
+					WarningType::Always, "warning: segment 128 is deprecated.",
+					"Remove 'Segment=\"128\"' from the xml to use virtual addresses\n");
 #endif
 			}
 			else
 			{
-				throw std::runtime_error(
+				HANDLE_ERROR_PROCESS(
+					WarningType::Always,
 					StringHelper::Sprintf("error: invalid segment value '%s': must be a decimal "
 				                          "number between 0 and 15 inclusive",
-				                          segmentXml));
+				                          segmentXml),
+					"");
 			}
 		}
 	}
@@ -176,18 +189,16 @@ void ZFile::ParseXML(tinyxml2::XMLElement* reader, const std::string& filename)
 	if (mode == ZFileMode::Extract || mode == ZFileMode::ExternalFile)
 	{
 		if (!File::Exists((basePath / name).string()))
-			throw std::runtime_error(
-				StringHelper::Sprintf("Error! File %s does not exist.", (basePath / name).c_str()));
+		{
+			std::string errorHeader = StringHelper::Sprintf("binary file '%s' does not exist.",
+			                                                (basePath / name).c_str());
+			HANDLE_ERROR_PROCESS(WarningType::Always, errorHeader, "");
+		}
 
 		rawData = File::ReadAllBytes((basePath / name).string());
 
-		/*
-		 * TODO: In OoT repo ovl_Boss_Sst has a wrong RangeEnd (0xAD40 instead of 0xAD70),
-		 * so uncommenting the following produces wrong behavior.
-		 * If somebody fixes that in OoT repo, uncomment this. I'm too tired of fixing XMLs.
-		 */
-		// if (reader->Attribute("RangeEnd") == nullptr)
-		// rangeEnd = rawData.size();
+		if (reader->Attribute("RangeEnd") == nullptr)
+		rangeEnd = rawData.size();
 	}
 
 	std::unordered_set<std::string> nameSet;
@@ -211,20 +222,17 @@ void ZFile::ParseXML(tinyxml2::XMLElement* reader, const std::string& filename)
 
 			if (offsetSet.find(offsetXml) != offsetSet.end())
 			{
-				throw std::runtime_error(StringHelper::Sprintf(
-					"ZFile::ParseXML: Error in '%s'.\n\t Repeated 'Offset' attribute: %s \n",
-					name.c_str(), offsetXml));
+				std::string errorHeader =
+					StringHelper::Sprintf("repeated 'Offset' attribute: %s", offsetXml);
+				HANDLE_ERROR_PROCESS(WarningType::InvalidXML, errorHeader, "");
 			}
 			offsetSet.insert(offsetXml);
 		}
-		else if (Globals::Instance->warnNoOffset)
-		{
-			fprintf(stderr, "Warning No offset specified for: %s", nameXml);
-		}
-		else if (Globals::Instance->errorNoOffset)
+		else
 		{
-			throw std::runtime_error(
-				StringHelper::Sprintf("Error no offset specified for %s", nameXml));
+			HANDLE_WARNING_RESOURCE(WarningType::MissingOffsets, this, nullptr, rawDataIndex,
+			                        StringHelper::Sprintf("no offset specified for %s.", nameXml),
+			                        "");
 		}
 
 		if (Globals::Instance->verbosity >= VerbosityLevel::VERBOSITY_INFO)
@@ -234,9 +242,9 @@ void ZFile::ParseXML(tinyxml2::XMLElement* reader, const std::string& filename)
 		{
 			if (outNameSet.find(outNameXml) != outNameSet.end())
 			{
-				throw std::runtime_error(StringHelper::Sprintf(
-					"ZFile::ParseXML: Error in '%s'.\n\t Repeated 'OutName' attribute: %s \n",
-					name.c_str(), outNameXml));
+				std::string errorHeader =
+					StringHelper::Sprintf("repeated 'OutName' attribute: %s", outNameXml);
+				HANDLE_ERROR_PROCESS(WarningType::InvalidXML, errorHeader, "");
 			}
 			outNameSet.insert(outNameXml);
 		}
@@ -244,9 +252,9 @@ void ZFile::ParseXML(tinyxml2::XMLElement* reader, const std::string& filename)
 		{
 			if (nameSet.find(nameXml) != nameSet.end())
 			{
-				throw std::runtime_error(StringHelper::Sprintf(
-					"ZFile::ParseXML: Error in '%s'.\n\t Repeated 'Name' attribute: %s \n",
-					name.c_str(), nameXml));
+				std::string errorHeader =
+					StringHelper::Sprintf("repeated 'Name' attribute: %s", nameXml);
+				HANDLE_ERROR_PROCESS(WarningType::InvalidXML, errorHeader, "");
 			}
 			nameSet.insert(nameXml);
 		}
@@ -279,16 +287,14 @@ void ZFile::ParseXML(tinyxml2::XMLElement* reader, const std::string& filename)
 		}
 		else if (std::string_view(child->Name()) == "File")
 		{
-			throw std::runtime_error(StringHelper::Sprintf(
-				"ZFile::ParseXML: Error in '%s'.\n\t Can't declare a File inside a File.\n",
-				name.c_str()));
+			std::string errorHeader = "Can't declare a <File> inside a <File>";
+			HANDLE_ERROR_PROCESS(WarningType::InvalidXML, errorHeader, "");
 		}
 		else
 		{
-			throw std::runtime_error(
-				StringHelper::Sprintf("ZFile::ParseXML: Error in '%s'.\n\t Unknown element found "
-			                          "inside a File element: '%s'.\n",
-			                          name.c_str(), nodeName.c_str()));
+			std::string errorHeader = StringHelper::Sprintf(
+				"Unknown element found inside a <File> element: %s", nodeName.c_str());
+			HANDLE_ERROR_PROCESS(WarningType::InvalidXML, errorHeader, "");
 		}
 	}
 }
@@ -1232,11 +1238,12 @@ bool ZFile::HandleUnaccountedAddress(uint32_t currentAddress, uint32_t lastAddr,
 		{
 			Declaration* currentDecl = declarations.at(currentAddress);
 
-			fprintf(stderr,
-			        "WARNING: Intersection detected from 0x%06X:0x%06X (%s), conflicts with "
-			        "0x%06X (%s)\n",
-			        lastAddr, lastAddr + lastSize, lastDecl->varName.c_str(), currentAddress,
-			        currentDecl->varName.c_str());
+			std::string intersectionInfo = StringHelper::Sprintf(
+				"Resource from 0x%06X:0x%06X (%s) conflicts with 0x%06X (%s).", lastAddr,
+				lastAddr + lastSize, lastDecl->varName.c_str(), currentAddress,
+				currentDecl->varName.c_str());
+			HANDLE_WARNING_RESOURCE(WarningType::Intersection, this, nullptr, currentAddress,
+			                        "intersection detected", intersectionInfo);
 		}
 	}
 
@@ -1307,25 +1314,17 @@ bool ZFile::HandleUnaccountedAddress(uint32_t currentAddress, uint32_t lastAddr,
 				diff, src);
 			decl->isUnaccounted = true;
 
-			if (Globals::Instance->warnUnaccounted)
+			if (nonZeroUnaccounted)
 			{
-				if (nonZeroUnaccounted)
-				{
-					fprintf(stderr,
-					        "Warning in file: %s (%s)\n"
-					        "\t A non-zero unaccounted block was found at offset '0x%06X'.\n"
-					        "\t Block size: '0x%X'.\n",
-					        xmlFilePath.c_str(), name.c_str(), unaccountedAddress, diff);
-				}
-				else if (diff >= 16)
-				{
-					fprintf(stderr,
-					        "Warning in file: %s (%s)\n"
-					        "\t A big (size>=0x10) zero-only unaccounted block was found "
-					        "at offset '0x%06X'.\n"
-					        "\t Block size: '0x%X'.\n",
-					        xmlFilePath.c_str(), name.c_str(), unaccountedAddress, diff);
-				}
+				HANDLE_WARNING_RESOURCE(WarningType::Unaccounted, this, nullptr, unaccountedAddress,
+				                        "a non-zero unaccounted block was found",
+				                        StringHelper::Sprintf("Block size: '0x%X'", diff));
+			}
+			else if (diff >= 16)
+			{
+				HANDLE_WARNING_RESOURCE(WarningType::Unaccounted, this, nullptr, unaccountedAddress,
+				                        "a big (size>=0x10) zero-only unaccounted block was found",
+				                        StringHelper::Sprintf("Block size: '0x%X'", diff));
 			}
 		}
 	}