External/yaml-cpp
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Moved token enums into Token scope

Browse Source
This commit is contained in:
Jesse Beder 2009-09-05 02:28:11 +00:00
parent 1db573dd30
commit 19673ff01a
8 changed files with 86 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/map.cpp
View File

@ -59,8 +59,8 @@ namespace YAML
// split based on start token
switch(pScanner->peek().type) {
case TT_BLOCK_MAP_START: ParseBlock(pScanner, state); break;
case TT_FLOW_MAP_START: ParseFlow(pScanner, state); break;
case Token::BLOCK_MAP_START: ParseBlock(pScanner, state); break;
case Token::FLOW_MAP_START: ParseFlow(pScanner, state); break;
default: break;
}
}
@ -75,10 +75,10 @@ namespace YAML
throw ParserException(Mark::null(), ErrorMsg::END_OF_MAP);
Token token = pScanner->peek();
if(token.type != TT_KEY && token.type != TT_VALUE && token.type != TT_BLOCK_MAP_END)
if(token.type != Token::KEY && token.type != Token::VALUE && token.type != Token::BLOCK_MAP_END)
throw ParserException(token.mark, ErrorMsg::END_OF_MAP);
if(token.type == TT_BLOCK_MAP_END) {
if(token.type == Token::BLOCK_MAP_END) {
pScanner->pop();
break;
}
@ -86,13 +86,13 @@ namespace YAML
std::auto_ptr <Node> pKey(new Node), pValue(new Node);
// grab key (if non-null)
if(token.type == TT_KEY) {
if(token.type == Token::KEY) {
pScanner->pop();
pKey->Parse(pScanner, state);
}
// now grab value (optional)
if(!pScanner->empty() && pScanner->peek().type == TT_VALUE) {
if(!pScanner->empty() && pScanner->peek().type == Token::VALUE) {
pScanner->pop();
pValue->Parse(pScanner, state);
}
@ -113,13 +113,13 @@ namespace YAML
Token& token = pScanner->peek();
// first check for end
if(token.type == TT_FLOW_MAP_END) {
if(token.type == Token::FLOW_MAP_END) {
pScanner->pop();
break;
}
// now it better be a key
if(token.type != TT_KEY)
if(token.type != Token::KEY)
throw ParserException(token.mark, ErrorMsg::END_OF_MAP_FLOW);
pScanner->pop();
@ -130,16 +130,16 @@ namespace YAML
pKey->Parse(pScanner, state);
// now grab value (optional)
if(!pScanner->empty() && pScanner->peek().type == TT_VALUE) {
if(!pScanner->empty() && pScanner->peek().type == Token::VALUE) {
pScanner->pop();
pValue->Parse(pScanner, state);
}
// now eat the separator (or could be a map end, which we ignore - but if it's neither, then it's a bad node)
Token& nextToken = pScanner->peek();
if(nextToken.type == TT_FLOW_ENTRY)
if(nextToken.type == Token::FLOW_ENTRY)
pScanner->pop();
else if(nextToken.type != TT_FLOW_MAP_END)
else if(nextToken.type != Token::FLOW_MAP_END)
throw ParserException(nextToken.mark, ErrorMsg::END_OF_MAP_FLOW);
// assign the map with the actual pointers

16
src/node.cpp
View File

@ -88,15 +88,15 @@ namespace YAML
// now split based on what kind of node we should be
switch(pScanner->peek().type) {
case TT_SCALAR:
case Token::SCALAR:
m_pContent = new Scalar;
break;
case TT_FLOW_SEQ_START:
case TT_BLOCK_SEQ_START:
case Token::FLOW_SEQ_START:
case Token::BLOCK_SEQ_START:
m_pContent = new Sequence;
break;
case TT_FLOW_MAP_START:
case TT_BLOCK_MAP_START:
case Token::FLOW_MAP_START:
case Token::BLOCK_MAP_START:
m_pContent = new Map;
break;
default:
@ -124,9 +124,9 @@ namespace YAML
return;
switch(pScanner->peek().type) {
case TT_TAG: ParseTag(pScanner, state); break;
case TT_ANCHOR: ParseAnchor(pScanner, state); break;
case TT_ALIAS: ParseAlias(pScanner, state); break;
case Token::TAG: ParseTag(pScanner, state); break;
case Token::ANCHOR: ParseAnchor(pScanner, state); break;
case Token::ALIAS: ParseAlias(pScanner, state); break;
default: return;
}
}

6
src/parser.cpp
View File

@ -46,14 +46,14 @@ namespace YAML
return;
// first eat doc start (optional)
if(m_pScanner->peek().type == TT_DOC_START)
if(m_pScanner->peek().type == Token::DOC_START)
m_pScanner->pop();
// now parse our root node
document.Parse(m_pScanner, m_state);
// and finally eat any doc ends we see
while(!m_pScanner->empty() && m_pScanner->peek().type == TT_DOC_END)
while(!m_pScanner->empty() && m_pScanner->peek().type == Token::DOC_END)
m_pScanner->pop();
// clear anchors from the scanner, which are no longer relevant
@ -71,7 +71,7 @@ namespace YAML
break;
Token& token = m_pScanner->peek();
if(token.type != TT_DIRECTIVE)
if(token.type != Token::DIRECTIVE)
break;
// we keep the directives from the last document if none are specified;

14
src/scanner.cpp
View File

@ -31,7 +31,7 @@ namespace YAML
EnsureTokensInQueue();
if(!m_tokens.empty()) {
// Saved anchors shouldn't survive popping the document end marker
if (m_tokens.front().type == TT_DOC_END) {
if (m_tokens.front().type == Token::DOC_END) {
ClearAnchors();
}
m_tokens.pop();
@ -60,11 +60,11 @@ namespace YAML
Token& token = m_tokens.front();
// if this guy's valid, then we're done
if(token.status == TS_VALID)
if(token.status == Token::VALID)
return;
// here's where we clean up the impossible tokens
if(token.status == TS_INVALID) {
if(token.status == Token::INVALID) {
m_tokens.pop();
continue;
}
@ -263,9 +263,9 @@ namespace YAML
// now push
m_indents.push(indent);
if(type == IndentMarker::SEQ)
m_tokens.push(Token(TT_BLOCK_SEQ_START, INPUT.mark()));
m_tokens.push(Token(Token::BLOCK_SEQ_START, INPUT.mark()));
else if(type == IndentMarker::MAP)
m_tokens.push(Token(TT_BLOCK_MAP_START, INPUT.mark()));
m_tokens.push(Token(Token::BLOCK_MAP_START, INPUT.mark()));
else
assert(false);
@ -319,9 +319,9 @@ namespace YAML
IndentMarker::INDENT_TYPE type = m_indents.top().type;
m_indents.pop();
if(type == IndentMarker::SEQ)
m_tokens.push(Token(TT_BLOCK_SEQ_END, INPUT.mark()));
m_tokens.push(Token(Token::BLOCK_SEQ_END, INPUT.mark()));
else if(type == IndentMarker::MAP)
m_tokens.push(Token(TT_BLOCK_MAP_END, INPUT.mark()));
m_tokens.push(Token(Token::BLOCK_MAP_END, INPUT.mark()));
}
// GetTopIndent

28
src/scantoken.cpp
View File

@ -50,7 +50,7 @@ namespace YAML
params.push_back(param);
}
Token token(TT_DIRECTIVE, mark);
Token token(Token::DIRECTIVE, mark);
token.value = name;
token.params = params;
m_tokens.push(token);
@ -66,7 +66,7 @@ namespace YAML
// eat
Mark mark = INPUT.mark();
INPUT.eat(3);
m_tokens.push(Token(TT_DOC_START, mark));
m_tokens.push(Token(Token::DOC_START, mark));
}
// DocEnd
@ -79,7 +79,7 @@ namespace YAML
// eat
Mark mark = INPUT.mark();
INPUT.eat(3);
m_tokens.push(Token(TT_DOC_END, mark));
m_tokens.push(Token(Token::DOC_END, mark));
}
// FlowStart
@ -93,7 +93,7 @@ namespace YAML
// eat
Mark mark = INPUT.mark();
char ch = INPUT.get();
TOKEN_TYPE type = (ch == Keys::FlowSeqStart ? TT_FLOW_SEQ_START : TT_FLOW_MAP_START);
Token::TYPE type = (ch == Keys::FlowSeqStart ? Token::FLOW_SEQ_START : Token::FLOW_MAP_START);
m_tokens.push(Token(type, mark));
}
@ -109,7 +109,7 @@ namespace YAML
// eat
Mark mark = INPUT.mark();
char ch = INPUT.get();
TOKEN_TYPE type = (ch == Keys::FlowSeqEnd ? TT_FLOW_SEQ_END : TT_FLOW_MAP_END);
Token::TYPE type = (ch == Keys::FlowSeqEnd ? Token::FLOW_SEQ_END : Token::FLOW_MAP_END);
m_tokens.push(Token(type, mark));
}
@ -121,7 +121,7 @@ namespace YAML
// eat
Mark mark = INPUT.mark();
INPUT.eat(1);
m_tokens.push(Token(TT_FLOW_ENTRY, mark));
m_tokens.push(Token(Token::FLOW_ENTRY, mark));
}
// BlockEntry
@ -141,7 +141,7 @@ namespace YAML
// eat
Mark mark = INPUT.mark();
INPUT.eat(1);
m_tokens.push(Token(TT_BLOCK_ENTRY, mark));
m_tokens.push(Token(Token::BLOCK_ENTRY, mark));
}
// Key
@ -164,7 +164,7 @@ namespace YAML
// eat
Mark mark = INPUT.mark();
INPUT.eat(1);
m_tokens.push(Token(TT_KEY, mark));
m_tokens.push(Token(Token::KEY, mark));
}
// Value
@ -199,7 +199,7 @@ namespace YAML
// eat
Mark mark = INPUT.mark();
INPUT.eat(1);
m_tokens.push(Token(TT_VALUE, mark));
m_tokens.push(Token(Token::VALUE, mark));
}
// AnchorOrAlias
@ -231,7 +231,7 @@ namespace YAML
throw ParserException(INPUT.mark(), alias ? ErrorMsg::CHAR_IN_ALIAS : ErrorMsg::CHAR_IN_ANCHOR);
// and we're done
Token token(alias ? TT_ALIAS : TT_ANCHOR, mark);
Token token(alias ? Token::ALIAS : Token::ANCHOR, mark);
token.value = name;
m_tokens.push(token);
}
@ -268,7 +268,7 @@ namespace YAML
handle = "!";
}
Token token(TT_TAG, mark);
Token token(Token::TAG, mark);
token.value = handle;
token.params.push_back(suffix);
m_tokens.push(token);
@ -305,7 +305,7 @@ namespace YAML
//if(Exp::IllegalCharInScalar.Matches(INPUT))
// throw ParserException(INPUT.mark(), ErrorMsg::CHAR_IN_SCALAR);
Token token(TT_SCALAR, mark);
Token token(Token::SCALAR, mark);
token.value = scalar;
m_tokens.push(token);
}
@ -344,7 +344,7 @@ namespace YAML
scalar = ScanScalar(INPUT, params);
m_simpleKeyAllowed = false;
Token token(TT_SCALAR, mark);
Token token(Token::SCALAR, mark);
token.value = scalar;
m_tokens.push(token);
}
@ -409,7 +409,7 @@ namespace YAML
// simple keys always ok after block scalars (since we're gonna start a new line anyways)
m_simpleKeyAllowed = true;
Token token(TT_SCALAR, mark);
Token token(Token::SCALAR, mark);
token.value = scalar;
m_tokens.push(token);
}

16
src/sequence.cpp
View File

@ -66,8 +66,8 @@ namespace YAML
// split based on start token
switch(pScanner->peek().type) {
case TT_BLOCK_SEQ_START: ParseBlock(pScanner, state); break;
case TT_FLOW_SEQ_START: ParseFlow(pScanner, state); break;
case Token::BLOCK_SEQ_START: ParseBlock(pScanner, state); break;
case Token::FLOW_SEQ_START: ParseFlow(pScanner, state); break;
default: break;
}
}
@ -82,11 +82,11 @@ namespace YAML
throw ParserException(Mark::null(), ErrorMsg::END_OF_SEQ);
Token token = pScanner->peek();
if(token.type != TT_BLOCK_ENTRY && token.type != TT_BLOCK_SEQ_END)
if(token.type != Token::BLOCK_ENTRY && token.type != Token::BLOCK_SEQ_END)
throw ParserException(token.mark, ErrorMsg::END_OF_SEQ);
pScanner->pop();
if(token.type == TT_BLOCK_SEQ_END)
if(token.type == Token::BLOCK_SEQ_END)
break;
Node *pNode = new Node;
@ -95,7 +95,7 @@ namespace YAML
// check for null
if(!pScanner->empty()) {
const Token& token = pScanner->peek();
if(token.type == TT_BLOCK_ENTRY || token.type == TT_BLOCK_SEQ_END)
if(token.type == Token::BLOCK_ENTRY || token.type == Token::BLOCK_SEQ_END)
continue;
}
@ -113,7 +113,7 @@ namespace YAML
throw ParserException(Mark::null(), ErrorMsg::END_OF_SEQ_FLOW);
// first check for end
if(pScanner->peek().type == TT_FLOW_SEQ_END) {
if(pScanner->peek().type == Token::FLOW_SEQ_END) {
pScanner->pop();
break;
}
@ -125,9 +125,9 @@ namespace YAML
// now eat the separator (or could be a sequence end, which we ignore - but if it's neither, then it's a bad node)
Token& token = pScanner->peek();
if(token.type == TT_FLOW_ENTRY)
if(token.type == Token::FLOW_ENTRY)
pScanner->pop();
else if(token.type != TT_FLOW_SEQ_END)
else if(token.type != Token::FLOW_SEQ_END)
throw ParserException(token.mark, ErrorMsg::END_OF_SEQ_FLOW);
}
}

14
src/simplekey.cpp
View File

@ -14,17 +14,17 @@ namespace YAML
void Scanner::SimpleKey::Validate()
{
if(pMapStart)
pMapStart->status = TS_VALID;
pMapStart->status = Token::VALID;
if(pKey)
pKey->status = TS_VALID;
pKey->status = Token::VALID;
}
void Scanner::SimpleKey::Invalidate()
{
if(pMapStart)
pMapStart->status = TS_INVALID;
pMapStart->status = Token::INVALID;
if(pKey)
pKey->status = TS_INVALID;
pKey->status = Token::INVALID;
}
// InsertSimpleKey
@ -37,12 +37,12 @@ namespace YAML
// first add a map start, if necessary
key.pMapStart = PushIndentTo(INPUT.column(), IndentMarker::MAP);
if(key.pMapStart)
key.pMapStart->status = TS_UNVERIFIED;
key.pMapStart->status = Token::UNVERIFIED;
// then add the (now unverified) key
m_tokens.push(Token(TT_KEY, INPUT.mark()));
m_tokens.push(Token(Token::KEY, INPUT.mark()));
key.pKey = &m_tokens.back();
key.pKey->status = TS_UNVERIFIED;
key.pKey->status = Token::UNVERIFIED;
m_simpleKeys.push(key);
}

54
src/token.h
View File

@ -11,29 +11,6 @@
namespace YAML
{
enum TOKEN_STATUS { TS_VALID, TS_INVALID, TS_UNVERIFIED };
enum TOKEN_TYPE {
TT_DIRECTIVE,
TT_DOC_START,
TT_DOC_END,
TT_BLOCK_SEQ_START,
TT_BLOCK_MAP_START,
TT_BLOCK_SEQ_END,
TT_BLOCK_MAP_END,
TT_BLOCK_ENTRY,
TT_FLOW_SEQ_START,
TT_FLOW_MAP_START,
TT_FLOW_SEQ_END,
TT_FLOW_MAP_END,
TT_FLOW_ENTRY,
TT_KEY,
TT_VALUE,
TT_ANCHOR,
TT_ALIAS,
TT_TAG,
TT_SCALAR
};
const std::string TokenNames[] = {
"DIRECTIVE",
"DOC_START",
@ -57,7 +34,32 @@ namespace YAML
};
struct Token {
Token(TOKEN_TYPE type_, const Mark& mark_): status(TS_VALID), type(type_), mark(mark_) {}
// enums
enum STATUS { VALID, INVALID, UNVERIFIED };
enum TYPE {
DIRECTIVE,
DOC_START,
DOC_END,
BLOCK_SEQ_START,
BLOCK_MAP_START,
BLOCK_SEQ_END,
BLOCK_MAP_END,
BLOCK_ENTRY,
FLOW_SEQ_START,
FLOW_MAP_START,
FLOW_SEQ_END,
FLOW_MAP_END,
FLOW_ENTRY,
KEY,
VALUE,
ANCHOR,
ALIAS,
TAG,
SCALAR
};
// data
Token(TYPE type_, const Mark& mark_): status(VALID), type(type_), mark(mark_) {}
friend std::ostream& operator << (std::ostream& out, const Token& token) {
out << TokenNames[token.type] << std::string(": ") << token.value;
@ -66,8 +68,8 @@ namespace YAML
return out;
}
TOKEN_STATUS status;
TOKEN_TYPE type;
STATUS status;
TYPE type;
Mark mark;
std::string value;
std::vector <std::string> params;