--- a/src/YAMLCommand.h	Tue Dec 01 23:30:00 2020 +0100
+++ b/src/YAMLCommand.h	Thu Dec 03 17:16:09 2020 +0100
@@ -1,6 +1,6 @@
 /**
  * Relational pipes
- * Copyright © 2019 František Kučera (Frantovo.cz, GlobalCode.info)
+ * Copyright © 2020 František Kučera (Frantovo.cz, GlobalCode.info)
  *
  * This program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,6 +21,8 @@
 #include <memory>
 #include <vector>
 
+#include <yaml.h>
+
 #include <relpipe/writer/RelationalWriter.h>
 #include <relpipe/writer/typedefs.h>
 
@@ -32,12 +34,123 @@
 private:
 	std::wstring_convert<codecvt_utf8<wchar_t>> convertor; // TODO: support also other encodings.
 
+	class YAMLEvent {
+	private:
+		yaml_event_t event;
+	public:
+
+		YAMLEvent(yaml_event_t event) : event(event) {
+		}
+
+		virtual ~YAMLEvent() {
+			yaml_event_delete(&event);
+		}
+
+		const yaml_event_type_t getType() const {
+			return event.type;
+		}
+
+		const yaml_event_t* getEvent() const {
+			return &event;
+		}
+
+		YAMLEvent(const YAMLEvent&) = delete;
+		YAMLEvent& operator=(const YAMLEvent&) = delete;
+	};
+
+	class YAMLParser {
+	private:
+		yaml_parser_t yamlParser;
+		std::istream* input = nullptr;
+
+		static int readFromInput(void* instance, unsigned char* buffer, size_t size, size_t* length) {
+			std::istream* input = ((YAMLParser*) instance)->input;
+			input->read((char*) buffer, size);
+			*length = input->gcount();
+			return (input->good() || input->eof()) ? 1 : 0;
+		}
+	public:
+
+		YAMLParser() {
+			yaml_parser_initialize(&yamlParser);
+		}
+
+		virtual ~YAMLParser() {
+			yaml_parser_delete(&yamlParser);
+		}
+
+		YAMLParser(const YAMLParser&) = delete;
+		YAMLParser& operator=(const YAMLParser&) = delete;
+
+		void setInput(std::istream* input) {
+			this->input = input;
+			yaml_parser_set_input(&yamlParser, readFromInput, (void*) this);
+		}
+
+		YAMLEvent* next() {
+			yaml_event_t event;
+			int result = yaml_parser_parse(&yamlParser, &event);
+			return result == 1 && event.type != yaml_event_type_e::YAML_NO_EVENT ? new YAMLEvent(event) : nullptr; // 1 = OK in yaml.h; YAML_NO_EVENT = end
+		}
+	};
+
+	YAMLParser parser;
+
+	using YAMLEvent_p = std::shared_ptr<YAMLEvent>;
+
+	enum class Mode {
+		ROOT,
+		RELATIONS_SEQUENCE,
+		MAPPING,
+		MAP_KEY
+	};
+
+	std::vector<Mode> mode;
+
+	/**
+	 * Both YAML and XML strings are in UTF-8.
+	 */
+	const char* y2x(yaml_char_t* value) {
+		return value ? (const char*) value : "";
+	}
+
 public:
 
+	YAMLCommand() {
+	}
+
+	virtual ~YAMLCommand() {
+	}
+
 	void process(std::istream& input, std::shared_ptr<relpipe::writer::RelationalWriter> writer) {
+		parser.setInput(&input);
+
 		std::vector<relpipe::writer::AttributeMetadata> attributesMetadata;
 		attributesMetadata.push_back(relpipe::writer::AttributeMetadata{L"todo", relpipe::writer::TypeId::STRING});
 		writer->startRelation(L"YAML", attributesMetadata, true);
+
+		mode.push_back(Mode::ROOT);
+		std::string itemName;
+
+		writer->writeAttribute(L"before cycle");
+		for (YAMLEvent_p event = YAMLEvent_p(parser.next()); event; event = YAMLEvent_p(parser.next())) {
+
+			if (event->getType() == YAML_NO_EVENT) { writer->writeAttribute(L"YAML_NO_EVENT");
+			} else if (event->getType() == YAML_STREAM_START_EVENT) { writer->writeAttribute(L"YAML_STREAM_START_EVENT");
+			} else if (event->getType() == YAML_STREAM_END_EVENT) { writer->writeAttribute(L"YAML_STREAM_END_EVENT");
+			} else if (event->getType() == YAML_DOCUMENT_START_EVENT) { writer->writeAttribute(L"YAML_DOCUMENT_START_EVENT");
+			} else if (event->getType() == YAML_DOCUMENT_END_EVENT) { writer->writeAttribute(L"YAML_DOCUMENT_END_EVENT");
+			} else if (event->getType() == YAML_ALIAS_EVENT) { writer->writeAttribute(L"YAML_ALIAS_EVENT");
+			} else if (event->getType() == YAML_SCALAR_EVENT) { writer->writeAttribute(L"YAML_SCALAR_EVENT");
+			} else if (event->getType() == YAML_SEQUENCE_START_EVENT) { writer->writeAttribute(L"YAML_SEQUENCE_START_EVENT");
+			} else if (event->getType() == YAML_SEQUENCE_END_EVENT) { writer->writeAttribute(L"YAML_SEQUENCE_END_EVENT");
+			} else if (event->getType() == YAML_MAPPING_START_EVENT) { writer->writeAttribute(L"YAML_MAPPING_START_EVENT");
+			} else if (event->getType() == YAML_MAPPING_END_EVENT) { writer->writeAttribute(L"YAML_MAPPING_END_EVENT");
+			} else { writer->writeAttribute(L"else???");
+				// TODO: unsupported type?
+			}
+		}
+		writer->writeAttribute(L"after cycle");
 	}
 };