diff -r 68443f5be176 -r 44679e468ba9 src/parser.cpp
--- a/src/parser.cpp	Sat Oct 05 23:47:03 2019 +0300
+++ b/src/parser.cpp	Sun Nov 03 12:17:41 2019 +0200
@@ -22,10 +22,16 @@
 #include "objecttypes/conditionaledge.h"
 #include "objecttypes/edge.h"
 #include "objecttypes/errorline.h"
+#include "objecttypes/metacommand.h"
 #include "objecttypes/modelobject.h"
 #include "objecttypes/polygon.h"
 #include "objecttypes/subfilereference.h"
 
+struct BodyParseError
+{
+	QString message;
+};
+
 /*
  * Constructs an LDraw parser
  */
@@ -41,7 +47,7 @@
 	return QString::fromUtf8(this->device.readLine()).trimmed();
 }
 
-static const QMap<QString, decltype(LDHeader::type)> typeStrings {
+static const QMap<QString, LDHeader::FileType> typeStrings {
 	{"Part", LDHeader::Part},
 	{"Subpart", LDHeader::Subpart},
 	{"Shortcut", LDHeader::Shortcut},
@@ -89,9 +95,9 @@
 			if (tokens.contains("Alias"))
 				header.qualfiers |= LDHeader::Alias;
 			if (tokens.contains("Physical_Color"))
-				header.qualfiers |= LDHeader::Physical_Color;
+				header.qualfiers |= LDHeader::PhysicalColour;
 			if (tokens.contains("Flexible_Section"))
-				header.qualfiers |= LDHeader::Flexible_Section;
+				header.qualfiers |= LDHeader::FlexibleSection;
 			return ParseSuccess;
 		}
 		else
@@ -101,7 +107,7 @@
 	}
 	else if (line == "0 BFC CERTIFY CCW")
 	{
-		winding = CounterClockwise;
+		winding = Anticlockwise;
 		return ParseSuccess;
 	}
 	else if (line == "0 BFC CERTIFY CW")
@@ -248,104 +254,162 @@
 			invertNext = true;
 			continue;
 		}
-		modelobjects::BaseObject* object = parseFromString(editor, line);
+		std::unique_ptr<modelobjects::BaseObject> object = parseFromString(line);
 		if (invertNext)
 		{
-			editor.setObjectProperty(object, modelobjects::Property::IsInverted, true);
+			editor.setObjectProperty(object.get(), modelobjects::Property::IsInverted, true);
 		}
+		editor.append(std::move(object));
 		invertNext = false;
 	}
 }
 
-namespace
+static Color colorFromString(const QString& colorString)
 {
-	namespace regexes
+	bool colorSucceeded;
+	const Color color = {colorString.toInt(&colorSucceeded)};
+	if (colorSucceeded)
+	{
+		return color;
+	}
+	else
 	{
-		static const QRegExp comment {R"(^\s*0\s*\/\/\s*(.+)$)"};
-		static const QRegExp metacommand {R"(^\s*0\s*(.+)$)"};
-		static const QRegExp edgeline
-		{
-			R"(^\s*2)" // starting 2-token
-			R"(\s+(\d+))" // colour
-			R"(((?:\s+[^\s]+){3}))" // 1st vertex
-			R"(((?:\s+[^\s]+){3}))" // 2nd vertex
-			R"(\s*$)" // end
-		};
-		static const QRegExp triangle
+		throw BodyParseError{"colour was not an integer value"};
+	}
+}
+
+static Vertex vertexFromStrings(
+	const QStringList& tokens,
+	const int startingPosition)
+{
+	bool ok_x;
+	const float x = tokens[startingPosition].toFloat(&ok_x);
+	bool ok_y;
+	const float y = tokens[startingPosition + 1].toFloat(&ok_y);
+	bool ok_z;
+	const float z = tokens[startingPosition + 2].toFloat(&ok_z);
+	if (not ok_x or not ok_y or not ok_z)
+	{
+		throw BodyParseError{"vertex contained illegal co-ordinates"};
+	}
+	return {x, y, z};
+}
+
+static Matrix3x3 matrixFromStrings(const QStringList& tokens, const int startingPosition)
+{
+	Matrix3x3 result;
+	for (int i = 0; i < 9; i += 1)
+	{
+		const int row = i / 3;
+		const int column = i % 3;
+		const int index = i + startingPosition;
+		if (index >= tokens.size())
 		{
-			R"(^\s*3)" // starting 3-token
-			R"(\s+(\d+))" // colour
-			R"(((?:\s+[^\s]+){3}))" // 1st vertex
-			R"(((?:\s+[^\s]+){3}))" // 2nd vertex
-			R"(((?:\s+[^\s]+){3}))" // 3rd vertex
-			R"(\s*$)" // end
-		};
-		static const QRegExp quadrilateral
+			throw BodyParseError{"too few tokens available"};
+		}
+		bool ok;
+		result(row, column) = tokens[index].toFloat(&ok);
+		if (not ok)
 		{
-			R"(^\s*4)" // starting 4-token
-			R"(\s+(\d+))" // colour
-			R"(((?:\s+[^\s]+){3}))" // 1st vertex
-			R"(((?:\s+[^\s]+){3}))" // 2nd vertex
-			R"(((?:\s+[^\s]+){3}))" // 3rd vertex
-			R"(((?:\s+[^\s]+){3}))" // 4th vertex
-			R"(\s*$)" // end
-		};
-		static const QRegExp conditionaledge
-		{
-			R"(^\s*5)" // starting 5-token
-			R"(\s+(\d+))" // colour
-			R"(((?:\s+[^\s]+){3}))" // 1st vertex
-			R"(((?:\s+[^\s]+){3}))" // 2nd vertex
-			R"(((?:\s+[^\s]+){3}))" // 1st control point
-			R"(((?:\s+[^\s]+){3}))" // 2nd control point
-			R"(\s*$)" // end
-		};
+			throw BodyParseError{"non-numeric values for matrix"};
+		}
+	}
+	return result;
+}
+
+static std::unique_ptr<modelobjects::BaseObject> parseType0Line(
+	const QString& line,
+	const QStringList& tokens)
+{
+	Q_UNUSED(tokens)
+	if (line.startsWith("0 //"))
+	{
+		return std::make_unique<modelobjects::Comment>(line.mid(std::strlen("0 //")).simplified());
+	}
+	else
+	{
+		return std::make_unique<modelobjects::MetaCommand>(line.mid(1).simplified());
 	}
 }
 
-static Vertex vertexFromString(const QString& vertex_string)
+static std::unique_ptr<modelobjects::SubfileReference> parseType1Line(
+	const QString& line,
+	const QStringList& tokens)
 {
-	static const QRegExp pattern {R"(^\s*([^\s]+)\s+([^\s]+)\s+([^\s]+)\s*$)"};
-	const bool succeeded = pattern.exactMatch(vertex_string);
-	if (succeeded)
+	Q_UNUSED(line)
+	constexpr int colorPosition = 1;
+	constexpr int transformPosition = 2; // 2..10
+	constexpr int positionPosition = 11; // 11..13
+	constexpr int namePosition = 14;
+	if (tokens.size() != 15)
 	{
-		const float x = pattern.cap(1).toFloat(nullptr);
-		const float y = pattern.cap(2).toFloat(nullptr);
-		const float z = pattern.cap(3).toFloat(nullptr);
-		return {x, y, z};
+		throw BodyParseError{"wrong amount of tokens in a type-1 line"};
 	}
-	else
-	{
-		return {};
-	}
+	const Color color = colorFromString(tokens[colorPosition]);
+	const Vertex position = vertexFromStrings(tokens, positionPosition);
+	const Matrix3x3 transform = matrixFromStrings(tokens, transformPosition);
+	const QString& name = tokens[namePosition];
+	return std::make_unique<modelobjects::SubfileReference>(position, transform, name, color);
 }
 
-static modelobjects::Edge* parseEdgeline(
-	Model::EditContext& editor,
-	const QString& line)
+template<typename T, int NumVertices>
+static std::unique_ptr<T> parsePolygon(
+	const QString& line,
+	const QStringList& tokens)
 {
-	const bool succeeded = regexes::edgeline.exactMatch(line);
-	if (succeeded)
+	Q_UNUSED(line)
+	constexpr int colorPosition = 1;
+	auto vertexPosition = [](int n) { return 2 + 3*n; };
+	if (tokens.size() != 2 + 3 * NumVertices)
+	{
+		throw BodyParseError{"wrong amount of tokens"};
+	}
+	const Color color = colorFromString(tokens[colorPosition]);
+	QVector<Vertex> vertices;
+	vertices.reserve(NumVertices);
+	for (int i = 0; i < NumVertices; i += 1)
+	{
+		vertices.append(vertexFromStrings(tokens, vertexPosition(i)));
+	}
+	return std::make_unique<T>(vertices, color);
+}
+
+std::unique_ptr<modelobjects::BaseObject> Parser::parseFromString(QString line)
+{
+	line = line.simplified();
+	try
 	{
-		const Color colour = {regexes::edgeline.cap(1).toInt(nullptr)};
-		const Vertex v_1 = vertexFromString(regexes::edgeline.cap(2));
-		const Vertex v_2 = vertexFromString(regexes::edgeline.cap(3));
-		return editor.append<modelobjects::Edge>(v_1, v_2, colour);
+		const QStringList tokens = line.split(QRegExp{R"(\s+)"});
+		if (tokens.empty())
+		{
+			return std::make_unique<modelobjects::Empty>();
+		}
+		bool ok_code;
+		const int code = tokens[0].toInt(&ok_code);
+		if (not ok_code)
+		{
+			throw BodyParseError{"line type was not an integer"};
+		}
+		switch (code)
+		{
+		case 0:
+			return parseType0Line(line, tokens);
+		case 1:
+			return parseType1Line(line, tokens);
+		case 2:
+			return parsePolygon<modelobjects::Edge, 2>(line, tokens);
+		case 3:
+			return parsePolygon<modelobjects::Triangle, 3>(line, tokens);
+		case 4:
+			return parsePolygon<modelobjects::Quadrilateral, 4>(line, tokens);
+		case 5:
+			return parsePolygon<modelobjects::ConditionalEdge, 4>(line, tokens);
+		default:
+			throw BodyParseError{utility::format("bad line type '%1'", code)};
+		}
 	}
-	else
+	catch(const BodyParseError& error)
 	{
-		return nullptr;
+		return std::make_unique<modelobjects::ErrorLine>(line, error.message);
 	}
 }
-
-modelobjects::BaseObject* Parser::parseFromString(
-	Model::EditContext& editor,
-	const QString& line)
-{
-	modelobjects::Edge* edge = parseEdgeline(editor, line);
-	if (edge)
-	{
-		return edge;
-	}
-	return editor.append<modelobjects::ErrorLine>(line);
-}