Moved the three scalar token scanning functions back to scantoken.cpp, so scanscalar.cpp now only has the main scalar scanning function.

Renamed ScanScalarInfo to ScanScalarParams.

scantoken.cpp

@@ -2,6 +2,7 @@
 #include "token.h"
 #include "exceptions.h"
 #include "exp.h"
+#include "scanscalar.h"
 
 namespace YAML
 {
@@ -220,4 +221,124 @@ namespace YAML
 		pToken->value = tag;
 		return pToken;
 	}
+
+	// PlainScalarToken
+	template <> PlainScalarToken *Scanner::ScanToken(PlainScalarToken *pToken)
+	{
+		// set up the scanning parameters
+		ScanScalarParams params;
+		params.end = (m_flowLevel > 0 ? Exp::EndScalarInFlow : Exp::EndScalar) || (RegEx(' ') + Exp::Comment);
+		params.eatEnd = false;
+		params.indent = (m_flowLevel > 0 ? 0 : m_indents.top() + 1);
+		params.fold = true;
+		params.eatLeadingWhitespace = true;
+		params.trimTrailingSpaces = true;
+		params.chomp = CLIP;
+		params.onDocIndicator = BREAK;
+		params.onTabInIndentation = THROW;
+
+		// insert a potential simple key
+		if(m_simpleKeyAllowed)
+			InsertSimpleKey();
+
+		pToken->value = ScanScalar(INPUT, params);
+
+		// can have a simple key only if we ended the scalar by starting a new line
+		m_simpleKeyAllowed = params.leadingSpaces;
+
+		// finally, we can't have any colons in a scalar, so if we ended on a colon, there
+		// had better be a break after it
+		if(Exp::IllegalColonInScalar.Matches(INPUT))
+			throw IllegalScalar();
+
+		return pToken;
+	}
+
+	// QuotedScalarToken
+	template <> QuotedScalarToken *Scanner::ScanToken(QuotedScalarToken *pToken)
+	{
+		// eat single or double quote
+		char quote = INPUT.GetChar();
+		pToken->single = (quote == '\'');
+
+		// setup the scanning parameters
+		ScanScalarParams params;
+		params.end = (pToken->single ? RegEx(quote) && !Exp::EscSingleQuote : RegEx(quote));
+		params.eatEnd = true;
+		params.escape = (pToken->single ? '\'' : '\\');
+		params.indent = 0;
+		params.fold = true;
+		params.eatLeadingWhitespace = true;
+		params.trimTrailingSpaces = false;
+		params.chomp = CLIP;
+		params.onDocIndicator = THROW;
+
+		// insert a potential simple key
+		if(m_simpleKeyAllowed)
+			InsertSimpleKey();
+
+		pToken->value = ScanScalar(INPUT, params);
+		m_simpleKeyAllowed = false;
+
+		return pToken;
+	}
+
+	// BlockScalarToken
+	// . These need a little extra processing beforehand.
+	// . We need to scan the line where the indicator is (this doesn't count as part of the scalar),
+	//   and then we need to figure out what level of indentation we'll be using.
+	template <> BlockScalarToken *Scanner::ScanToken(BlockScalarToken *pToken)
+	{
+		ScanScalarParams params;
+		params.indent = 1;
+		params.detectIndent = true;
+
+		// eat block indicator ('|' or '>')
+		char indicator = INPUT.GetChar();
+		params.fold = (indicator == Keys::FoldedScalar);
+
+		// eat chomping/indentation indicators
+		int n = Exp::Chomp.Match(INPUT);
+		for(int i=0;i<n;i++) {
+			char ch = INPUT.GetChar();
+			if(ch == '+')
+				params.chomp = KEEP;
+			else if(ch == '-')
+				params.chomp = STRIP;
+			else if(Exp::Digit.Matches(ch)) {
+				if(ch == '0')
+					throw ZeroIndentationInBlockScalar();
+
+				params.indent = ch - '0';
+				params.detectIndent = false;
+			}
+		}
+
+		// now eat whitespace
+		while(Exp::Blank.Matches(INPUT))
+			INPUT.Eat(1);
+
+		// and comments to the end of the line
+		if(Exp::Comment.Matches(INPUT))
+			while(INPUT && !Exp::Break.Matches(INPUT))
+				INPUT.Eat(1);
+
+		// if it's not a line break, then we ran into a bad character inline
+		if(INPUT && !Exp::Break.Matches(INPUT))
+			throw UnexpectedCharacterInBlockScalar();
+
+		// set the initial indentation
+		if(m_indents.top() >= 0)
+			params.indent += m_indents.top();
+
+		params.eatLeadingWhitespace = false;
+		params.trimTrailingSpaces = false;
+		params.onTabInIndentation = THROW;
+
+		pToken->value = ScanScalar(INPUT, params);
+
+		// simple keys always ok after block scalars (since we're gonna start a new line anyways)
+		m_simpleKeyAllowed = true;
+		return pToken;
+	}
 }