parse-waves.cpp

#include <cstring>

#pragma warning(push, 0)
#include <FL/filename.H>
#pragma warning(pop)

#include "parse-waves.h"

#include "utils.h"

Parsed_Waves::Parsed_Waves(const char *d) {
	parse_waves(d);
}

std::string Parsed_Waves::get_error_message() const {
	switch (_result) {
	case Result::WAVES_OK:
		return "OK.";
	case Result::WAVES_BAD_FILE:
		return "Cannot open wave samples file.";
	case Result::WAVES_NO_WAVES:
		return "No waves defined.";
	case Result::WAVES_UNRECOGNIZED_MACRO:
		return "Line " + std::to_string(_line_number) +
			": Unrecognized macro.";
	case Result::WAVES_TOO_FEW_SAMPLES:
		return "Line " + std::to_string(_line_number) +
			": Too few samples.";
	case Result::WAVES_TOO_MANY_SAMPLES:
		return "Line " + std::to_string(_line_number) +
			": Too many samples.";
	case Result::WAVES_INVALID_VALUE:
		return "Line " + std::to_string(_line_number) +
			": Invalid value.";
	case Result::WAVES_NULL:
		return "No *.asm file chosen.";
	default:
		return "Unspecified error.";
	}
}

Parsed_Waves::Result Parsed_Waves::parse_wave(std::istringstream &lss, Wave &wave, bool nybbles) {
	size_t i = 0;
	for (std::string token; std::getline(lss, token, ',');) {
		if (i >= NUM_WAVE_SAMPLES) {
			return Result::WAVES_TOO_MANY_SAMPLES;
		}

		int32_t v;
		if (!parse_value(token, v)) {
			return Result::WAVES_INVALID_VALUE;
		}
		if (nybbles) {
			if (v < 0 || v > 15) {
				return Result::WAVES_INVALID_VALUE;
			}
			wave[i++] = v;
		}
		else {
			if (v < 0 || v > 255) {
				return Result::WAVES_INVALID_VALUE;
			}
			int32_t hi = v >> 4;
			int32_t lo = v & 0x0F;
			wave[i++] = hi;
			wave[i++] = lo;
		}
	}
	if (i != NUM_WAVE_SAMPLES) {
		return Result::WAVES_TOO_FEW_SAMPLES;
	}
	return Result::WAVES_OK;
}

Parsed_Waves::Result Parsed_Waves::parse_waves(const char *d) {
	char waves_file[FL_PATH_MAX] = {};

	// first, try crysaudio/wave_samples.asm
	strcpy(waves_file, d);
	strcat(waves_file, DIR_SEP "crysaudio" DIR_SEP "wave_samples.asm");
	if (try_parse_waves(waves_file) != Result::WAVES_BAD_FILE) {
		return _result;
	}
	// second, try audio/wave_samples.asm
	strcpy(waves_file, d);
	strcat(waves_file, DIR_SEP "audio" DIR_SEP "wave_samples.asm");
	if (try_parse_waves(waves_file) != Result::WAVES_BAD_FILE) {
		return _result;
	}
	// third, try wave_samples.asm
	strcpy(waves_file, d);
	strcat(waves_file, DIR_SEP "wave_samples.asm");
	if (try_parse_waves(waves_file) != Result::WAVES_BAD_FILE) {
		return _result;
	}

	return _result;
}

static bool get_label(std::istringstream &iss, std::string &l, const std::string &scope = "") {
	iss >> l;
	rtrim(l, ":");
	trim(l);
	if (l.size() == 0) {
		return false;
	}
	if (l[0] == '.') {
		l = scope + l;
	}
	return true;
}

Parsed_Waves::Result Parsed_Waves::try_parse_waves(const char *f) {
	_waves_file = f;
	_waves_label = "";
	_waves.clear();
	_num_parsed_waves = 0;
	_uses_dn = false;
	_result = Result::WAVES_NULL;
	_line_number = 0;

	std::ifstream ifs;
	open_ifstream(ifs, f);
	if (!ifs.good()) {
		return (_result = Result::WAVES_BAD_FILE);
	}

	while (ifs.good()) {
		std::string line;
		std::getline(ifs, line);
		_line_number += 1;
		remove_comment(line);
		rtrim(line);
		if (line.size() == 0) { continue; }
		bool indented = is_indented(line);
		std::istringstream lss(line);

		if (!indented) {
			if (_waves_label.size() == 0 && _waves.size() == 0) {
				get_label(lss, _waves_label);
			}
		}
		else {
			std::string macro;
			if (!leading_macro(lss, macro)) {
				return (_result = Result::WAVES_UNRECOGNIZED_MACRO);
			}
			bool nybbles = equals_ignore_case(macro, "dn");
			if (!nybbles && !equals_ignore_case(macro, "db")) {
				return (_result = Result::WAVES_UNRECOGNIZED_MACRO);
			}
			_uses_dn |= nybbles;

			Wave wave;
			Result r = parse_wave(lss, wave, nybbles);
			if (r != Result::WAVES_OK) {
				return (_result = r);
			}
			_waves.push_back(wave);
		}
	}

	_num_parsed_waves = (int32_t)_waves.size();
	_waves.resize(16);

	if (_num_parsed_waves == 0) {
		return (_result = Result::WAVES_NO_WAVES);
	}
	return (_result = Result::WAVES_OK);
}