Simplified Parser interface.

include/plasp/utils/Parser.h

@@ -27,15 +27,20 @@ class Parser
 		size_t row() const;
 		size_t column() const;
 
+		CharacterType currentCharacter() const;
+
 		template<typename Type>
 		Type parse();
 
-		template<class CharacterCondition>
+		template<class WhiteSpacePredicate, class CharacterPredicate>
-		void parseUntil(std::vector<std::string> &container, CharacterCondition characterCondition);
+		std::string parseIdentifier(WhiteSpacePredicate whiteSpacePredicate, CharacterPredicate characterPredicate);
 
 		template<typename Type>
 		void expect(const Type &expectedValue);
 
+		template<class WhiteSpacePredicate>
+		void skipWhiteSpace(WhiteSpacePredicate whiteSpacePredicate);
+
 		void skipWhiteSpace();
 		void skipLine();
 
@@ -63,38 +68,38 @@ class Parser
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-template<class CharacterCondition>
+template<class WhiteSpacePredicate, class CharacterPredicate>
-void Parser::parseUntil(std::vector<std::string> &container, CharacterCondition characterCondition)
+std::string Parser::parseIdentifier(WhiteSpacePredicate whiteSpacePredicate, CharacterPredicate characterPredicate)
 {
+	skipWhiteSpace(whiteSpacePredicate);
+
+	std::string value;
+
 	while (true)
 	{
-		skipWhiteSpace();
+		const auto character = *m_position;
 
-		std::string value;
+		if (!characterPredicate(character))
+			return value;
 
-		while (true)
+		value.push_back(character);
-		{
+		advance();
-			const auto character = *m_position;
-
-			if (characterCondition(character))
-			{
-				container.emplace_back(std::move(value));
-				return;
-			}
-
-			if (std::isspace(character))
-				break;
-
-			value.push_back(character);
-			advance();
-		}
-
-		container.emplace_back(std::move(value));
 	}
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+template<class WhiteSpacePredicate>
+void Parser::skipWhiteSpace(WhiteSpacePredicate whiteSpacePredicate)
+{
+	checkStream();
+
+	while (whiteSpacePredicate(*m_position))
+		advance();
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 }
 }
 

src/plasp/sas/Predicate.cpp

@@ -28,10 +28,21 @@ Predicate Predicate::fromSAS(utils::Parser &parser)
 
 		predicate.m_name = parser.parse<std::string>();
 
-		parser.parseUntil(predicate.m_arguments, [](const auto character)
+		while (true)
-			{
+		{
-				return character == '\n';
+			// Parse arguments until reaching newline
-			});
+			parser.skipWhiteSpace(
+				[&](const auto character)
+				{
+					return character != '\n' && std::isspace(character);
+				});
+
+			if (parser.currentCharacter() == '\n')
+				break;
+
+			const auto value = parser.parse<std::string>();
+			predicate.m_arguments.emplace_back(std::move(value));
+		}
 	}
 	catch (const std::exception &e)
 	{

src/plasp/utils/Parser.cpp

@@ -54,6 +54,15 @@ size_t Parser::column() const
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+Parser::CharacterType Parser::currentCharacter() const
+{
+	checkStream();
+
+	return *m_position;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 void Parser::checkStream() const
 {
 	if (m_position == EndOfFile)
@@ -100,10 +109,11 @@ bool Parser::advanceIf(CharacterType expectedCharacter)
 
 void Parser::skipWhiteSpace()
 {
-	checkStream();
+	return skipWhiteSpace(
-
+		[](const auto character)
-	while (std::isspace(*m_position))
+		{
-		advance();
+			return std::isspace(character);
+		});
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////