boxberry/src/BBBParser.cc

#include "BBBParser.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <errno.h>

int BBBParser::get() {
	int ch = stream_.get();
	if (ch == '\n') {
		line_ += 1;
		ch_ = 1;
	} else {
		ch_ += 1;
	}

	return ch;
}

BBBParser::Operator BBBParser::readOperator() {
	int ch2 = peek2();
	if (peek() == ':' && ch2 == '=') {
		skip(); // ':'
		skip(); // '='
		return Operator::COLON_EQUALS;
	} else if (peek() == '+' && ch2 == '=') {
		skip(); // '+'
		skip(); // '='
		return Operator::PLUS_EQUALS;
	} else if (peek() == '=' && ch2 == '+') {
		skip(); // '='
		skip(); // '+'
		return Operator::EQUALS_PLUS;
	}

	return Operator::NONE;
}

void BBBParser::skip(char expected) {
	int ch = get();
	if (ch == EOF) {
		error(std::string("Expected '") + expected + "', got EOF");
	} else if (ch != expected) {
		error(std::string("Expected '") + expected + "', got '" + (char)ch + "'");
	}
}

[[noreturn]] void BBBParser::error(std::string msg) {
	throw BBBParseError(std::to_string(line_) + ":" + std::to_string(ch_) + ": " + msg);
}

static bool isWhitespace(int ch) {
	if (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n')
		return true;
	return false;
}

void BBBParser::skipWhitespace() {
	if (flags_ & FLAG_ONE_LINE) {
		int ch;
		while (isWhitespace(ch = peek()) && ch != '\r' && ch != '\n')
			get();
	} else {
		while (isWhitespace(peek()))
			get();
	}
}

char BBBParser::parseEscape() {
	skip(); // '\'
	int ch;
	switch (ch = get()) {
		case EOF:
			error("Unexpected EOF");

		case 'n':
			return '\n';

		case 'r':
			return '\r';

		case 't':
			return '\t';

		default:
			return (char)ch;
	}
}

static void appendVariableToString(
		const BBBParser::Variables &vars, std::string &name,
		std::string &value) {
	if (name.size() == 0)
		return;

	auto it = vars.find(name);
	if (it == vars.end())
		return;

	auto &vec = it->second;
	bool first = true;
	for (auto &part: vec) {
		if (!first) {
			value += ' ';
		}

		first = false;
		value += part;
	}
}

static void appendVariableToArray(
		const BBBParser::Variables &vars, const std::string &name,
		std::vector<std::string> &values) {
	if (name.size() == 0)
		return;

	auto it = vars.find(name);
	if (it == vars.end())
		return;

	auto &vec = it->second;
	for (auto &part: vec) {
		values.push_back(part);
	}
}

void BBBParser::parseExpansion(const Variables &vars, std::vector<std::string> &values) {
	skip(); // '$'

	std::string str;
	switch (peek()) {
	case '{':
		skip();
		parseString(vars, str, '}');
		skip('}');
		appendVariableToArray(vars, str, values);
		break;

	default:
		if (!parseIdentifier(str)) {
			error("No identifier after $.");
		}

		appendVariableToArray(vars, str, values);
		break;
	}
}

void BBBParser::parseQuotedExpansion(const Variables &vars, std::string &content) {
	skip(); // '$'

	std::string str;
	switch (peek()) {
	case '{':
		skip();
		parseString(vars, str, '}');
		skip('}');
		appendVariableToString(vars, str, content);
		break;

	default:
		if (!parseIdentifier(str)) {
			error("No identifier after $.");
		}

		appendVariableToString(vars, str, content);
		break;
	}
}

void BBBParser::parseQuotedString(const Variables &vars, std::string &content) {
	skip(); // '"'

	int ch;
	while ((ch = peek()) != EOF) {
		switch (ch) {
		case EOF:
			error("Unexpected EOF");

		case '\\':
			content.push_back(parseEscape());
			break;

		case '$':
			parseQuotedExpansion(vars, content);
			break;

		case '"':
			skip();
			return;

		default:
			content.push_back(get());
			break;
		}
	}
}

bool BBBParser::parseString(const Variables &vars, std::string &content, int sep) {
	bool success = false;
	int ch;
	while (1) {
		ch = peek();
		if ((sep > 0 && ch == sep) || isWhitespace(ch)) {
			return success;
		}

		switch (ch) {
		case EOF:
			return success;

		case '\\':
			content.push_back(parseEscape());
			success = true;
			break;

		case '$':
			parseQuotedExpansion(vars, content);
			success = true;
			break;

		case '"':
			parseQuotedString(vars, content);
			success = true;
			break;

		default:
			if (ch == ':' && peek2() == '=')
				return success;

			content.push_back(get());
			success = true;
			break;
		}
	}
}

bool BBBParser::parseIdentifier(std::string &content) {
	int ch = peek();
	if (!(
			(ch >= 'a' && ch <= 'z') ||
			(ch >= 'A' && ch <= 'Z') ||
			(ch == '_'))) {
		return false;
	}

	content += get();

	while (1) {
		ch = peek();
		if (!(
				(ch >= '0' && ch <= '9') ||
				(ch >= 'a' && ch <= 'z') ||
				(ch >= 'A' && ch <= 'Z') ||
				(ch == '_'))) {
			return true;
		}

		content += get();
	}
}

void BBBParser::parse(Variables &vars) {
	std::string key, value;
	std::vector<std::string> values;

	skipWhitespace();
	if (!parseString(vars, key)) {
		return;
	}

	Operator prevOper = readOperator();
	if (prevOper == Operator::NONE) {
		error("Expected operator.");
	}

	auto doAssignment = [&] {
		switch (prevOper) {
		case Operator::COLON_EQUALS:
			vars[key] = std::move(values);
			values.clear();
			break;

		case Operator::PLUS_EQUALS:
			{
				auto &vec = vars[key];
				vec.reserve(vec.size() + values.size());
				for (size_t i = 0; i < values.size(); ++i) {
					vec.push_back(std::move(values[i]));
				}
			}
			values.clear();
			break;

		case Operator::EQUALS_PLUS:
			{
				auto &vec = vars[key];
				vec.reserve(vec.size() + values.size());
				for (size_t i = 0; i < vec.size(); ++i) {
					values.push_back(std::move(vec[i]));
				}
				vec = std::move(values);
			}
			values.clear();
			break;

		case Operator::NONE:
			break;
		}
	};

	while (true) {
		skipWhitespace();

		// Parse next value
		if (peek() == '$') {
			parseExpansion(vars, values);
			value.clear();
			continue; // We can't have an assignment after an expansion
		} else if (!parseString(vars, value)) {
			break;
		}

		skipWhitespace();

		// If there's an operator next, the value we just read was a actually a key.
		// Otherwise, it was just another value.
		Operator op = readOperator();
		if (op == Operator::NONE) {
			values.push_back(std::move(value));
			value.clear();
		} else {
			if (value.size() == 0) {
				error("Expected string before assignment operator");
			}

			doAssignment();
			prevOper = op;
			key = std::move(value);
			value.clear();
		}
	}

	doAssignment();
}