From 03e6b5b991270e96e62152deca6c5595423ae11b Mon Sep 17 00:00:00 2001 From: Jesse Beder Date: Tue, 8 Jul 2008 20:31:48 +0000 Subject: [PATCH] Centralized the error messages to one location. --- exceptions.h | 35 +++++++++++++++++++++++++++++++++++ exp.cpp | 7 +++---- map.cpp | 10 +++++----- node.cpp | 8 ++++---- parser.cpp | 8 ++++---- scanner.cpp | 2 +- scanscalar.cpp | 6 +++--- scantoken.cpp | 33 ++++++++++++--------------------- sequence.cpp | 8 ++++---- 9 files changed, 71 insertions(+), 46 deletions(-) diff --git a/exceptions.h b/exceptions.h index 017b0b1..f3a27f0 100644 --- a/exceptions.h +++ b/exceptions.h @@ -18,4 +18,39 @@ namespace YAML // representation exceptions class InvalidScalar: public RepresentationException {}; class BadDereference: public RepresentationException {}; + + // error messages + namespace ErrorMsg + { + const std::string YAML_DIRECTIVE_ARGS = "YAML directives must have exactly one argument"; + const std::string YAML_VERSION = "bad YAML version: "; + const std::string YAML_MAJOR_VERSION = "YAML major version too large"; + const std::string TAG_DIRECTIVE_ARGS = "TAG directives must have exactly two arguments"; + const std::string END_OF_MAP = "end of map not found"; + const std::string END_OF_MAP_FLOW = "end of map flow not found"; + const std::string END_OF_SEQ = "end of sequence not found"; + const std::string END_OF_SEQ_FLOW = "end of sequence flow not found"; + const std::string MULTIPLE_TAGS = "cannot assign multiple tags to the same node"; + const std::string MULTIPLE_ANCHORS = "cannot assign multiple anchors to the same node"; + const std::string MULTIPLE_ALIASES = "cannot assign multiple aliases to the same node"; + const std::string ALIAS_CONTENT = "aliases can't have any content, *including* tags"; + const std::string INVALID_HEX = "bad character found while scanning hex number"; + const std::string INVALID_UNICODE = "invalid unicode: "; + const std::string INVALID_ESCAPE = "unknown escape character: "; + const std::string UNKNOWN_TOKEN = "unknown token"; + const std::string DOC_IN_SCALAR = "illegal document indicator in scalar"; + const std::string EOF_IN_SCALAR = "illegal EOF in scalar"; + const std::string CHAR_IN_SCALAR = "illegal character in scalar"; + const std::string TAB_IN_INDENTATION = "illegal tab when looking for indentation"; + const std::string FLOW_END = "illegal flow end"; + const std::string BLOCK_ENTRY = "illegal block entry"; + const std::string MAP_KEY = "illegal map key"; + const std::string MAP_VALUE = "illegal map value"; + const std::string ALIAS_NOT_FOUND = "alias not found after *"; + const std::string ANCHOR_NOT_FOUND = "anchor not found after &"; + const std::string CHAR_IN_ALIAS = "illegal character found while scanning alias"; + const std::string CHAR_IN_ANCHOR = "illegal character found while scanning anchor"; + const std::string ZERO_INDENT_IN_BLOCK = "cannot set zero indentation for a block scalar"; + const std::string CHAR_IN_BLOCK = "unexpected character in block scalar"; + } } diff --git a/exp.cpp b/exp.cpp index f766de6..05b1b24 100644 --- a/exp.cpp +++ b/exp.cpp @@ -19,7 +19,7 @@ namespace YAML else if('0' <= ch && ch <= '9') digit = ch - '0'; else - throw ParserException(line, column, "bad character found while scanning hex number"); + throw ParserException(line, column, ErrorMsg::INVALID_HEX); value = (value << 4) + digit; } @@ -48,7 +48,7 @@ namespace YAML // legal unicode? if((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) { std::stringstream msg; - msg << "invalid unicode: " << value; + msg << ErrorMsg::INVALID_UNICODE << value; throw ParserException(in.line, in.column, msg.str()); } @@ -106,8 +106,7 @@ namespace YAML } std::stringstream msg; - msg << "unknown escape character: " << ch; - throw ParserException(in.line, in.column, msg.str()); + throw ParserException(in.line, in.column, ErrorMsg::INVALID_ESCAPE + ch); } } } diff --git a/map.cpp b/map.cpp index 0687f34..19a3cb9 100644 --- a/map.cpp +++ b/map.cpp @@ -57,10 +57,10 @@ namespace YAML while(1) { Token *pToken = pScanner->PeekNextToken(); if(!pToken) - throw ParserException(-1, -1, "end of map not found"); + throw ParserException(-1, -1, ErrorMsg::END_OF_MAP); if(pToken->type != TT_KEY && pToken->type != TT_BLOCK_END) - throw ParserException(pToken->line, pToken->column, "end of map not found"); + throw ParserException(pToken->line, pToken->column, ErrorMsg::END_OF_MAP); pScanner->PopNextToken(); if(pToken->type == TT_BLOCK_END) @@ -96,7 +96,7 @@ namespace YAML while(1) { Token *pToken = pScanner->PeekNextToken(); if(!pToken) - throw ParserException(-1, -1, "end of map flow not found"); + throw ParserException(-1, -1, ErrorMsg::END_OF_MAP_FLOW); // first check for end if(pToken->type == TT_FLOW_MAP_END) { @@ -106,7 +106,7 @@ namespace YAML // now it better be a key if(pToken->type != TT_KEY) - throw ParserException(pToken->line, pToken->column, "end of map flow not found"); + throw ParserException(pToken->line, pToken->column, ErrorMsg::END_OF_MAP_FLOW); pScanner->PopNextToken(); @@ -128,7 +128,7 @@ namespace YAML if(pToken->type == TT_FLOW_ENTRY) pScanner->EatNextToken(); else if(pToken->type != TT_FLOW_MAP_END) - throw ParserException(pToken->line, pToken->column, "end of map flow not found"); + throw ParserException(pToken->line, pToken->column, ErrorMsg::END_OF_MAP_FLOW); m_data[pKey] = pValue; } catch(Exception& e) { diff --git a/node.cpp b/node.cpp index 78a2793..c878e9a 100644 --- a/node.cpp +++ b/node.cpp @@ -85,7 +85,7 @@ namespace YAML { Token *pToken = pScanner->PeekNextToken(); if(m_tag != "") - throw ParserException(pToken->line, pToken->column, "cannot assign multiple tags to the same node"); + throw ParserException(pToken->line, pToken->column, ErrorMsg::MULTIPLE_TAGS); m_tag = state.TranslateTag(pToken->value); @@ -98,7 +98,7 @@ namespace YAML { Token *pToken = pScanner->PeekNextToken(); if(m_anchor != "") - throw ParserException(pToken->line, pToken->column, "cannot assign multiple anchors to the same node"); + throw ParserException(pToken->line, pToken->column, ErrorMsg::MULTIPLE_ANCHORS); m_anchor = pToken->value; m_alias = false; @@ -109,9 +109,9 @@ namespace YAML { Token *pToken = pScanner->PeekNextToken(); if(m_anchor != "") - throw ParserException(pToken->line, pToken->column, "cannot assign multiple aliases to the same node"); + throw ParserException(pToken->line, pToken->column, ErrorMsg::MULTIPLE_ALIASES); if(m_tag != "") - throw ParserException(pToken->line, pToken->column, "aliases can't have any content, *including* tags"); + throw ParserException(pToken->line, pToken->column, ErrorMsg::ALIAS_CONTENT); m_anchor = pToken->value; m_alias = true; diff --git a/parser.cpp b/parser.cpp index f27a344..0f79d4f 100644 --- a/parser.cpp +++ b/parser.cpp @@ -90,17 +90,17 @@ namespace YAML void Parser::HandleYamlDirective(Token *pToken) { if(pToken->params.size() != 1) - throw ParserException(pToken->line, pToken->column, "YAML directives must have exactly one argument"); + throw ParserException(pToken->line, pToken->column, ErrorMsg::YAML_DIRECTIVE_ARGS); std::stringstream str(pToken->params[0]); str >> m_state.version.major; str.get(); str >> m_state.version.minor; if(!str || str.peek() != EOF) - throw ParserException(pToken->line, pToken->column, "bad YAML version: " + pToken->params[0]); + throw ParserException(pToken->line, pToken->column, ErrorMsg::YAML_VERSION + pToken->params[0]); if(m_state.version.major > 1) - throw ParserException(pToken->line, pToken->column, "YAML major version > 1"); + throw ParserException(pToken->line, pToken->column, ErrorMsg::YAML_MAJOR_VERSION); // TODO: warning on major == 1, minor > 2? } @@ -110,7 +110,7 @@ namespace YAML void Parser::HandleTagDirective(Token *pToken) { if(pToken->params.size() != 2) - throw ParserException(pToken->line, pToken->column, "TAG directives must have exactly two arguments"); + throw ParserException(pToken->line, pToken->column, ErrorMsg::TAG_DIRECTIVE_ARGS); std::string handle = pToken->params[0], prefix = pToken->params[1]; m_state.tags[handle] = prefix; diff --git a/scanner.cpp b/scanner.cpp index cfa330d..110d1a3 100644 --- a/scanner.cpp +++ b/scanner.cpp @@ -157,7 +157,7 @@ namespace YAML return ScanPlainScalar(); // don't know what it is! - throw ParserException(INPUT.line, INPUT.column, "unknown token"); + throw ParserException(INPUT.line, INPUT.column, ErrorMsg::UNKNOWN_TOKEN); } // ScanToNextToken diff --git a/scanscalar.cpp b/scanscalar.cpp index c83c091..c2cf2b9 100644 --- a/scanscalar.cpp +++ b/scanscalar.cpp @@ -35,7 +35,7 @@ namespace YAML if(params.onDocIndicator == BREAK) break; else if(params.onDocIndicator == THROW) - throw ParserException(INPUT.line, INPUT.column, "illegal document indicator in scalar"); + throw ParserException(INPUT.line, INPUT.column, ErrorMsg::DOC_IN_SCALAR); } foundNonEmptyLine = true; @@ -61,7 +61,7 @@ namespace YAML // eof? if we're looking to eat something, then we throw if(INPUT.peek() == EOF) { if(params.eatEnd) - throw ParserException(INPUT.line, INPUT.column, "illegal EOF in scalar"); + throw ParserException(INPUT.line, INPUT.column, ErrorMsg::EOF_IN_SCALAR); break; } @@ -97,7 +97,7 @@ namespace YAML while(Exp::Blank.Matches(INPUT)) { // we check for tabs that masquerade as indentation if(INPUT.peek() == '\t'&& INPUT.column < params.indent && params.onTabInIndentation == THROW) - throw ParserException(INPUT.line, INPUT.column, "illegal tab when looking for indentation"); + throw ParserException(INPUT.line, INPUT.column, ErrorMsg::TAB_IN_INDENTATION); if(!params.eatLeadingWhitespace) break; diff --git a/scantoken.cpp b/scantoken.cpp index 04dbfa8..7a12c9a 100644 --- a/scantoken.cpp +++ b/scantoken.cpp @@ -100,7 +100,7 @@ namespace YAML void Scanner::ScanFlowEnd() { if(m_flowLevel == 0) - throw ParserException(INPUT.line, INPUT.column, "illegal flow end"); + throw ParserException(INPUT.line, INPUT.column, ErrorMsg::FLOW_END); m_flowLevel--; m_simpleKeyAllowed = false; @@ -128,11 +128,11 @@ namespace YAML { // we better be in the block context! if(m_flowLevel > 0) - throw ParserException(INPUT.line, INPUT.column, "illegal block entry"); + throw ParserException(INPUT.line, INPUT.column, ErrorMsg::BLOCK_ENTRY); // can we put it here? if(!m_simpleKeyAllowed) - throw ParserException(INPUT.line, INPUT.column, "illegal block entry"); + throw ParserException(INPUT.line, INPUT.column, ErrorMsg::BLOCK_ENTRY); PushIndentTo(INPUT.column, true); m_simpleKeyAllowed = true; @@ -149,7 +149,7 @@ namespace YAML // handle keys diffently in the block context (and manage indents) if(m_flowLevel == 0) { if(!m_simpleKeyAllowed) - throw ParserException(INPUT.line, INPUT.column, "illegal map key"); + throw ParserException(INPUT.line, INPUT.column, ErrorMsg::MAP_KEY); PushIndentTo(INPUT.column, false); } @@ -177,7 +177,7 @@ namespace YAML // handle values diffently in the block context (and manage indents) if(m_flowLevel == 0) { if(!m_simpleKeyAllowed) - throw ParserException(INPUT.line, INPUT.column, "illegal map value"); + throw ParserException(INPUT.line, INPUT.column, ErrorMsg::MAP_VALUE); PushIndentTo(INPUT.column, false); } @@ -216,21 +216,12 @@ namespace YAML name += INPUT.get(); // we need to have read SOMETHING! - if(name.empty()) { - std::stringstream msg; - msg << (alias ? "alias" : "anchor"); - msg << " not found after "; - msg << (alias ? "*" : "&"); - throw ParserException(INPUT.line, INPUT.column, msg.str()); - } + if(name.empty()) + throw ParserException(INPUT.line, INPUT.column, alias ? ErrorMsg::ALIAS_NOT_FOUND : ErrorMsg::ANCHOR_NOT_FOUND); // and needs to end correctly - if(INPUT.peek() != EOF && !Exp::AnchorEnd.Matches(INPUT)) { - std::stringstream msg; - msg << "illegal character found while scanning "; - msg << (alias ? "alias" : "anchor"); - throw ParserException(INPUT.line, INPUT.column, msg.str()); - } + if(INPUT.peek() != EOF && !Exp::AnchorEnd.Matches(INPUT)) + throw ParserException(INPUT.line, INPUT.column, alias ? ErrorMsg::CHAR_IN_ALIAS : ErrorMsg::CHAR_IN_ANCHOR); // and we're done Token *pToken = new Token(alias ? TT_ALIAS : TT_ANCHOR, line, column); @@ -306,7 +297,7 @@ namespace YAML // 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 ParserException(INPUT.line, INPUT.column, "illegal character in scalar"); + throw ParserException(INPUT.line, INPUT.column, ErrorMsg::CHAR_IN_SCALAR); Token *pToken = new Token(TT_SCALAR, line, column); pToken->value = scalar; @@ -374,7 +365,7 @@ namespace YAML params.chomp = STRIP; else if(Exp::Digit.Matches(ch)) { if(ch == '0') - throw ParserException(INPUT.line, INPUT.column, "cannot set zero indentation for a block scalar"); + throw ParserException(INPUT.line, INPUT.column, ErrorMsg::ZERO_INDENT_IN_BLOCK); params.indent = ch - '0'; params.detectIndent = false; @@ -392,7 +383,7 @@ namespace YAML // if it's not a line break, then we ran into a bad character inline if(INPUT && !Exp::Break.Matches(INPUT)) - throw ParserException(INPUT.line, INPUT.column, "unexpected character in block scalar"); + throw ParserException(INPUT.line, INPUT.column, ErrorMsg::CHAR_IN_BLOCK); // set the initial indentation if(m_indents.top() >= 0) diff --git a/sequence.cpp b/sequence.cpp index b4cd495..8c1e3ca 100644 --- a/sequence.cpp +++ b/sequence.cpp @@ -68,10 +68,10 @@ namespace YAML while(1) { Token *pToken = pScanner->PeekNextToken(); if(!pToken) - throw ParserException(-1, -1, "end of sequence not found"); + throw ParserException(-1, -1, ErrorMsg::END_OF_SEQ); if(pToken->type != TT_BLOCK_ENTRY && pToken->type != TT_BLOCK_END) - throw ParserException(pToken->line, pToken->column, "end of sequence not found"); + throw ParserException(pToken->line, pToken->column, ErrorMsg::END_OF_SEQ); pScanner->PopNextToken(); if(pToken->type == TT_BLOCK_END) @@ -111,7 +111,7 @@ namespace YAML while(1) { Token *pToken = pScanner->PeekNextToken(); if(!pToken) - throw ParserException(-1, -1, "end of sequence flow not found"); + throw ParserException(-1, -1, ErrorMsg::END_OF_SEQ_FLOW); // first check for end if(pToken->type == TT_FLOW_SEQ_END) { @@ -129,7 +129,7 @@ namespace YAML if(pToken->type == TT_FLOW_ENTRY) pScanner->EatNextToken(); else if(pToken->type != TT_FLOW_SEQ_END) - throw ParserException(pToken->line, pToken->column, "end of sequence flow not found"); + throw ParserException(pToken->line, pToken->column, ErrorMsg::END_OF_SEQ_FLOW); } }