Add export to WAV command-line functionality

.gitignore

@@ -1,6 +1,11 @@
-# The build output folder
+# The build output folders
 build/
+build-debug/
 
 # Editor config files
 .vscode/
 .vs/
+
+# Audio files
+*.wav
+*.wav.asd

CMakeLists.txt

@@ -22,8 +22,8 @@
 cmake_minimum_required(VERSION 3.10)
 project(MilkyTracker)
 
-# Set C++ standard to C++98
-set(CMAKE_CXX_STANDARD 98)
+# Set C++ standard to C++11
+set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
 # Enable IDE solution folders
@@ -63,7 +63,9 @@ configure_file(
 )
 
 # Packaging
-if(APPLE)
+option(BUILD_DMG "Build DMG package on macOS" ON)
+
+if(APPLE AND BUILD_DMG)
     set(CPACK_GENERATOR DragNDrop)
     set(CPACK_DMG_VOLUME_NAME "${PROJECT_NAME} ${VER_FULL}")
     set(
@@ -225,6 +227,7 @@ add_subdirectory(src/fx)
 add_subdirectory(src/milkyplay)
 add_subdirectory(src/ppui)
 add_subdirectory(src/tracker)
+add_subdirectory(src/tools/export-to-wav)
 
 # Set MilkyTracker target as startup project in Visual Studio
 set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT tracker)

build.sh

@@ -1,9 +1,46 @@
 #!/bin/bash
 # https://crascit.com/2016/04/03/scripting-cmake-builds/
 
-cmake -E make_directory build
-pushd build
-cmake -DCMAKE_BUILD_TYPE=Release ..
-cmake --build . --config Release
+# Set defaults
+BUILD_TYPE="Release"
+BUILD_DMG=ON
+
+# Parse arguments
+while [[ $# -gt 0 ]]; do
+    case $1 in
+        Release|Debug)
+            BUILD_TYPE="$1"
+            ;;
+        --no-dmg)
+            BUILD_DMG=OFF
+            ;;
+        *)
+            echo "Unknown argument: $1"
+            echo "Usage: $0 [Release|Debug] [--no-dmg]"
+            exit 1
+            ;;
+    esac
+    shift
+done
+
+# Set build directory based on build type
+BUILD_DIR="build"
+CMAKE_FLAGS="-DCMAKE_BUILD_TYPE=$BUILD_TYPE -DBUILD_DMG=$BUILD_DMG"
+
+if [[ "$BUILD_TYPE" == "Debug" ]]; then
+    BUILD_DIR="build-debug"
+    # Add debug-specific flags
+    CMAKE_FLAGS="$CMAKE_FLAGS -DCMAKE_CXX_FLAGS_DEBUG='-g3'"
+fi
+
+echo "Building MilkyTracker in $BUILD_TYPE mode in $BUILD_DIR..."
+if [ "$BUILD_DMG" = "OFF" ]; then
+    echo "DMG generation: OFF"
+fi
+
+cmake -E make_directory $BUILD_DIR
+pushd $BUILD_DIR
+cmake $CMAKE_FLAGS ..
+cmake --build . --config $BUILD_TYPE
 cpack .
 popd

src/cli/CLIParser.cpp

@@ -0,0 +1,250 @@
+#include "CLIParser.h"
+#include <cstring>
+#include <cstdio>
+
+// Constructor is now a template in the header
+
+void CLIParser::addOption(const char* name, bool requiresValue, const char* description, const std::vector<std::string>& allowedValues, bool isHelpFlag)
+{
+	options.emplace_back(name, requiresValue, description, allowedValues, isHelpFlag);
+}
+
+void CLIParser::addPositionalArg(const char* name, const char* description, bool required)
+{
+	positionalArgs.emplace_back(name, description, required);
+}
+
+bool CLIParser::isValidOptionValue(const Option* opt, const char* value) const
+{
+	if (opt->allowedValues.empty()) {
+		return true;  // No restrictions
+	}
+
+	for (const auto& allowed : opt->allowedValues) {
+		if (allowed == value) {
+			return true;
+		}
+	}
+	return false;
+}
+
+bool CLIParser::parse()
+{
+	parsedOptions.clear();
+	parsedPositionalArgs.clear();
+	errorMessage.clear();
+	helpRequested = false;
+
+	size_t positionalIndex = 0;
+
+	for (int i = 1; i < argc; i++) {
+		const char* arg = argv[i];
+
+		if (isOption(arg)) {
+			const Option* opt = findOption(arg);
+			if (!opt) {
+				errorMessage = "Unknown option: ";
+				errorMessage += arg;
+				return false;
+			}
+
+			// Check if this is a help flag
+			if (opt->isHelpFlag) {
+				helpRequested = true;
+				return true;
+			}
+
+			if (opt->requiresValue) {
+				if (i + 1 >= argc) {
+					errorMessage = "Option requires value: ";
+					errorMessage += arg;
+					return false;
+				}
+				// Check that next argument isn't an option
+				const char* value = argv[i + 1];
+				if (isOption(value)) {
+					errorMessage = "Option requires value, but got another option: ";
+					errorMessage += arg;
+					errorMessage += " ";
+					errorMessage += value;
+					return false;
+				}
+
+				// Validate value against allowed values if any
+				if (!isValidOptionValue(opt, value)) {
+					errorMessage = "Invalid value for option ";
+					errorMessage += arg;
+					errorMessage += ": ";
+					errorMessage += value;
+					errorMessage += "\nAllowed values are: ";
+					for (size_t j = 0; j < opt->allowedValues.size(); j++) {
+						if (j > 0) errorMessage += ", ";
+						errorMessage += opt->allowedValues[j];
+					}
+					return false;
+				}
+
+				parsedOptions[opt->name] = value;
+				i++; // Skip the value we just processed
+			} else {
+				parsedOptions[opt->name] = "true";
+			}
+		} else {
+			if (positionalIndex >= positionalArgs.size()) {
+				errorMessage = "Too many positional arguments";
+				return false;
+			}
+			parsedPositionalArgs.push_back(arg);
+			positionalIndex++;
+		}
+	}
+
+	// If help was requested, no need to validate other args
+	if (helpRequested) {
+		return true;
+	}
+
+	// Check each position to ensure required args are satisfied
+	for (size_t i = 0; i < positionalArgs.size(); i++) {
+		bool isRequired = std::get<2>(positionalArgs[i]);
+		if (isRequired && i >= parsedPositionalArgs.size()) {
+			errorMessage = "Missing required argument: ";
+			errorMessage += std::get<0>(positionalArgs[i]);
+			return false;
+		}
+	}
+
+	return true;
+}
+
+bool CLIParser::hasOption(const char* name) const
+{
+	return parsedOptions.find(name) != parsedOptions.end();
+}
+
+const char* CLIParser::getOptionValue(const char* name) const
+{
+	auto it = parsedOptions.find(name);
+	return it != parsedOptions.end() ? it->second.c_str() : nullptr;
+}
+
+int CLIParser::getIntOptionValue(const char* name, int defaultValue) const
+{
+	const char* value = getOptionValue(name);
+	return value ? atoi(value) : defaultValue;
+}
+
+const char* CLIParser::getPositionalArg(size_t index) const
+{
+	return index < parsedPositionalArgs.size() ? parsedPositionalArgs[index].c_str() : nullptr;
+}
+
+size_t CLIParser::getPositionalArgCount() const
+{
+	return parsedPositionalArgs.size();
+}
+
+void CLIParser::printUsage() const
+{
+	fprintf(stderr, "Usage: %s", argv[0]);
+
+	// Print positional args in order
+	for (const auto& arg : positionalArgs) {
+		if (std::get<2>(arg)) {
+			fprintf(stderr, " <%s>", std::get<0>(arg).c_str());
+		} else {
+			fprintf(stderr, " [%s]", std::get<0>(arg).c_str());
+		}
+	}
+
+	fprintf(stderr, " [options]\n\nPositional arguments:\n");
+
+	// Print positional arg descriptions
+	for (const auto& arg : positionalArgs) {
+		fprintf(stderr, "  %-20s %s%s\n", 
+				std::get<0>(arg).c_str(), 
+				std::get<1>(arg).c_str(),
+				std::get<2>(arg) ? "" : " (optional)");
+	}
+
+	fprintf(stderr, "\nOptions:\n");
+
+	// Print option descriptions with allowed values
+	for (const auto& opt : options) {
+		if (opt.requiresValue) {
+			fprintf(stderr, "  %s <value>", opt.name.c_str());
+			fprintf(stderr, "%*s%s", 
+					static_cast<int>(20 - strlen(opt.name.c_str()) - 8), 
+					"", opt.description.c_str());
+
+			// Print allowed values if any
+			if (!opt.allowedValues.empty()) {
+				fprintf(stderr, " (allowed values: ");
+				for (size_t i = 0; i < opt.allowedValues.size(); i++) {
+					if (i > 0) fprintf(stderr, ", ");
+					fprintf(stderr, "%s", opt.allowedValues[i].c_str());
+				}
+				fprintf(stderr, ")");
+			}
+			fprintf(stderr, "\n");
+		} else {
+			fprintf(stderr, "  %s", opt.name.c_str());
+			fprintf(stderr, "%*s%s\n",
+					static_cast<int>(20 - strlen(opt.name.c_str())),
+					"", opt.description.c_str());
+		}
+	}
+
+	// Print additional help text if present
+	if (!additionalHelpText.empty()) {
+		fprintf(stderr, "\n%s", additionalHelpText.c_str());
+	}
+}
+
+const char* CLIParser::getError() const
+{
+	return errorMessage.c_str();
+}
+
+bool CLIParser::isOption(const char* arg) const
+{
+	return arg[0] == '-' && (arg[1] == '-' || isalpha(arg[1]));  // Accept both -- and -alpha
+}
+
+const CLIParser::Option* CLIParser::findOption(const char* name) const
+{
+	for (const auto& opt : options) {
+		if (opt.name == name) {
+			return &opt;
+		}
+	}
+	return nullptr;
+}
+
+void CLIParser::setPositionalArgValue(size_t index, const char* value) {
+	if (index < parsedPositionalArgs.size()) {
+		parsedPositionalArgs[index] = value;
+	}
+}
+
+bool CLIParser::hasPositionalArg(const char* name) const {
+	for (const auto& arg : positionalArgs) {
+		if (std::get<0>(arg) == name) {
+			return true;
+		}
+	}
+	return false;
+}
+
+void CLIParser::dumpParsedOptions() const {
+	fprintf(stderr, "\n=== Parsed Options ===\n");
+	for (const auto& opt : parsedOptions) {
+		fprintf(stderr, "Option: %s = %s\n", opt.first.c_str(), opt.second.c_str());
+	}
+
+	fprintf(stderr, "\n=== Positional Arguments ===\n");
+	for (size_t i = 0; i < parsedPositionalArgs.size(); i++) {
+		fprintf(stderr, "Arg[%zu]: %s\n", i, parsedPositionalArgs[i].c_str());
+	}
+	fprintf(stderr, "\n");
+}