summaryrefslogtreecommitdiffstats
path: root/external_libs/cpp/yaml-cpp/src/scanner.h
blob: bc8dcbe5489b84d8b6c7f32c00a12a24ae85e00e (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
#ifndef SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66
#define SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66

#if defined(_MSC_VER) || (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4
#pragma once
#endif


#include <ios>
#include <string>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include "ptr_vector.h"
#include "stream.h"
#include "token.h"

namespace YAML
{
	class Node;
	class RegEx;

	class Scanner
	{
	public:
		Scanner(std::istream& in);
		~Scanner();

		// token queue management (hopefully this looks kinda stl-ish)
		bool empty();
		void pop();
		Token& peek();

	private:
		struct IndentMarker {
			enum INDENT_TYPE { MAP, SEQ, NONE };
			enum STATUS { VALID, INVALID, UNKNOWN };
			IndentMarker(int column_, INDENT_TYPE type_): column(column_), type(type_), status(VALID), pStartToken(0) {}
		
			int column;
			INDENT_TYPE type;
			STATUS status;
			Token *pStartToken;
		};
		
		enum FLOW_MARKER { FLOW_MAP, FLOW_SEQ };
	
	private:	
		// scanning
		void EnsureTokensInQueue();
		void ScanNextToken();
		void ScanToNextToken();
		void StartStream();
		void EndStream();
		Token *PushToken(Token::TYPE type);
		
		bool InFlowContext() const { return !m_flows.empty(); }
		bool InBlockContext() const { return m_flows.empty(); }
		int GetFlowLevel() const { return m_flows.size(); }
		
		Token::TYPE GetStartTokenFor(IndentMarker::INDENT_TYPE type) const;
		IndentMarker *PushIndentTo(int column, IndentMarker::INDENT_TYPE type);
		void PopIndentToHere();
		void PopAllIndents();
		void PopIndent();
		int GetTopIndent() const;

		// checking input
		bool CanInsertPotentialSimpleKey() const;
		bool ExistsActiveSimpleKey() const;
		void InsertPotentialSimpleKey();
		void InvalidateSimpleKey();
		bool VerifySimpleKey();
		void PopAllSimpleKeys();
		
		void ThrowParserException(const std::string& msg) const;

		bool IsWhitespaceToBeEaten(char ch);
		const RegEx& GetValueRegex() const;

		struct SimpleKey {
			SimpleKey(const Mark& mark_, int flowLevel_);

			void Validate();
			void Invalidate();
			
			Mark mark;
			int flowLevel;
			IndentMarker *pIndent;
			Token *pMapStart, *pKey;
		};

		// and the tokens
		void ScanDirective();
		void ScanDocStart();
		void ScanDocEnd();
		void ScanBlockSeqStart();
		void ScanBlockMapSTart();
		void ScanBlockEnd();
		void ScanBlockEntry();
		void ScanFlowStart();
		void ScanFlowEnd();
		void ScanFlowEntry();
		void ScanKey();
		void ScanValue();
		void ScanAnchorOrAlias();
		void ScanTag();
		void ScanPlainScalar();
		void ScanQuotedScalar();
		void ScanBlockScalar();

	private:
		// the stream
		Stream INPUT;

		// the output (tokens)
		std::queue<Token> m_tokens;

		// state info
		bool m_startedStream, m_endedStream;
		bool m_simpleKeyAllowed;
		bool m_canBeJSONFlow;
		std::stack<SimpleKey> m_simpleKeys;
		std::stack<IndentMarker *> m_indents;
		ptr_vector<IndentMarker> m_indentRefs; // for "garbage collection"
		std::stack<FLOW_MARKER> m_flows;
	};
}

#endif // SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66