Skip to content

Y
yaml-cpp
Commit de290681 by Jesse Beder
Options

Added stream input to the regular expressions, greatly simplifying the usage (in… 

Added stream input to the regular expressions, greatly simplifying the usage (in particular, we no longer have to specify the number of characters to be checked).
parent 4e435b13
Showing with 232 additions and 85 deletions
regex.cpp
......@@ -2,30 +2,60 @@
namespace YAML
{
RegEx::RegEx(REGEX_OP op): m_op(op)
RegEx::RegEx(REGEX_OP op): m_op(op), m_pOp(0)
{
SetOp();
}
RegEx::RegEx(): m_op(REGEX_EMPTY)
RegEx::RegEx(const RegEx& rhs): m_pOp(0)
{
m_op = rhs.m_op;
m_a = rhs.m_a;
m_z = rhs.m_z;
m_params = rhs.m_params;
SetOp();
}
RegEx::RegEx(char ch): m_op(REGEX_MATCH), m_a(ch)
RegEx::RegEx(): m_op(REGEX_EMPTY), m_pOp(0)
{
SetOp();
}
RegEx::RegEx(char a, char z): m_op(REGEX_RANGE), m_a(a), m_z(z)
RegEx::RegEx(char ch): m_op(REGEX_MATCH), m_pOp(0), m_a(ch)
{
SetOp();
}
RegEx::RegEx(const std::string& str, REGEX_OP op): m_op(op)
RegEx::RegEx(char a, char z): m_op(REGEX_RANGE), m_pOp(0), m_a(a), m_z(z)
{
SetOp();
}
RegEx::RegEx(const std::string& str, REGEX_OP op): m_op(op), m_pOp(0)
{
for(unsigned i=0;i<str.size();i++)
m_params.push_back(RegEx(str[0]));
SetOp();
}
RegEx::~RegEx()
{
delete m_pOp;
}
void RegEx::SetOp()
{
delete m_pOp;
m_pOp = 0;
switch(m_op) {
case REGEX_MATCH: m_pOp = new MatchOperator; break;
case REGEX_RANGE: m_pOp = new RangeOperator; break;
case REGEX_OR: m_pOp = new OrOperator; break;
case REGEX_NOT: m_pOp = new NotOperator; break;
case REGEX_SEQ: m_pOp = new SeqOperator; break;
}
}
bool RegEx::Matches(char ch) const
......@@ -40,6 +70,11 @@ namespace YAML
return Match(str) >= 0;
}
bool RegEx::Matches(std::istream& in) const
{
return Match(in) >= 0;
}
// Match
// . Matches the given string against this regular expression.
// . Returns the number of characters matched.
......@@ -49,44 +84,36 @@ namespace YAML
// but that of course matches zero characters).
int RegEx::Match(const std::string& str) const
{
switch(m_op) {
case REGEX_EMPTY:
if(str.empty())
return 0;
return -1;
case REGEX_MATCH:
if(str.empty() || str[0] != m_a)
return -1;
return 1;
case REGEX_RANGE:
if(str.empty() || m_a > str[0] || m_z < str[0])
return -1;
return 1;
case REGEX_NOT:
if(m_params.empty())
return false;
if(m_params[0].Match(str) >= 0)
return -1;
return 1;
case REGEX_OR:
for(unsigned i=0;i<m_params.size();i++) {
int n = m_params[i].Match(str);
if(n >= 0)
return n;
}
return -1;
case REGEX_SEQ:
int offset = 0;
for(unsigned i=0;i<m_params.size();i++) {
int n = m_params[i].Match(str.substr(offset));
if(n == -1)
return -1;
offset += n;
}
return offset;
}
if(!m_pOp)
return -1;
return -1;
return m_pOp->Match(str, *this);
//case REGEX_EMPTY:
// if(str.empty())
// return 0;
// return -1;
}
// Match
// . The stream version does the same thing as the string version;
// REMEMBER that we only match from the start of the stream!
// . Note: the istream is not a const reference, but we guarantee
// that the pointer will be in the same spot, and we'll clear its
// flags before we end.
int RegEx::Match(std::istream& in) const
{
if(!m_pOp)
return -1;
int pos = in.tellg();
int ret = m_pOp->Match(in, *this);
// reset input stream!
in.clear();
in.seekg(pos);
return ret;
}
RegEx operator ! (const RegEx& ex)
......@@ -111,4 +138,107 @@ namespace YAML
ret.m_params.push_back(ex2);
return ret;
}
//////////////////////////////////////////////////////////////////////////////
// Operators
// MatchOperator
int RegEx::MatchOperator::Match(const std::string& str, const RegEx& regex) const
{
if(str.empty() || str[0] != regex.m_a)
return -1;
return 1;
}
int RegEx::MatchOperator::Match(std::istream& in, const RegEx& regex) const
{
if(!in || in.peek() != regex.m_a)
return -1;
return 1;
}
// RangeOperator
int RegEx::RangeOperator::Match(const std::string& str, const RegEx& regex) const
{
if(str.empty() || regex.m_a > str[0] || regex.m_z < str[0])
return -1;
return 1;
}
int RegEx::RangeOperator::Match(std::istream& in, const RegEx& regex) const
{
if(!in || regex.m_a > in.peek() || regex.m_z < in.peek())
return -1;
return 1;
}
// OrOperator
int RegEx::OrOperator::Match(const std::string& str, const RegEx& regex) const
{
for(unsigned i=0;i<regex.m_params.size();i++) {
int n = regex.m_params[i].Match(str);
if(n >= 0)
return n;
}
return -1;
}
int RegEx::OrOperator::Match(std::istream& in, const RegEx& regex) const
{
for(unsigned i=0;i<regex.m_params.size();i++) {
int n = regex.m_params[i].Match(in);
if(n >= 0)
return n;
}
return -1;
}
// NotOperator
int RegEx::NotOperator::Match(const std::string& str, const RegEx& regex) const
{
if(regex.m_params.empty())
return -1;
if(regex.m_params[0].Match(str) >= 0)
return -1;
return 1;
}
int RegEx::NotOperator::Match(std::istream& in, const RegEx& regex) const
{
if(regex.m_params.empty())
return -1;
if(regex.m_params[0].Match(in) >= 0)
return -1;
return 1;
}
// SeqOperator
int RegEx::SeqOperator::Match(const std::string& str, const RegEx& regex) const
{
int offset = 0;
for(unsigned i=0;i<regex.m_params.size();i++) {
int n = regex.m_params[i].Match(str.substr(offset));
if(n == -1)
return -1;
offset += n;
}
return offset;
}
int RegEx::SeqOperator::Match(std::istream& in, const RegEx& regex) const
{
int offset = 0;
for(unsigned i=0;i<regex.m_params.size();i++) {
int n = regex.m_params[i].Match(in);
if(n == -1)
return -1;
offset += n;
in.seekg(n, std::ios_base::cur);
}
return offset;
}
}
regex.h
......@@ -2,6 +2,7 @@
#include <vector>
#include <string>
#include <ios>
namespace YAML
{
......@@ -10,17 +11,55 @@ namespace YAML
// simplified regular expressions
// . Only straightforward matches (no repeated characters)
// . Only matches from start of string
class RegEx {
class RegEx
{
private:
struct Operator {
virtual ~Operator() {}
virtual int Match(const std::string& str, const RegEx& regex) const = 0;
virtual int Match(std::istream& in, const RegEx& regex) const = 0;
};
struct MatchOperator: public Operator {
virtual int Match(const std::string& str, const RegEx& regex) const;
virtual int Match(std::istream& in, const RegEx& regex) const;
};
struct RangeOperator: public Operator {
virtual int Match(const std::string& str, const RegEx& regex) const;
virtual int Match(std::istream& in, const RegEx& regex) const;
};
struct OrOperator: public Operator {
virtual int Match(const std::string& str, const RegEx& regex) const;
virtual int Match(std::istream& in, const RegEx& regex) const;
};
struct NotOperator: public Operator {
virtual int Match(const std::string& str, const RegEx& regex) const;
virtual int Match(std::istream& in, const RegEx& regex) const;
};
struct SeqOperator: public Operator {
virtual int Match(const std::string& str, const RegEx& regex) const;
virtual int Match(std::istream& in, const RegEx& regex) const;
};
public:
friend struct Operator;
RegEx();
RegEx(char ch);
RegEx(char a, char z);
RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ);
RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ);
RegEx(const RegEx& rhs);
~RegEx();
bool Matches(char ch) const;
bool Matches(const std::string& str) const;
bool Matches(std::istream& in) const;
int Match(const std::string& str) const;
int Match(std::istream& in) const;
friend RegEx operator ! (const RegEx& ex);
friend RegEx operator || (const RegEx& ex1, const RegEx& ex2);
......@@ -28,9 +67,11 @@ namespace YAML
private:
RegEx(REGEX_OP op);
void SetOp();
private:
REGEX_OP m_op;
Operator *m_pOp;
char m_a, m_z;
std::vector <RegEx> m_params;
};
......
scanner.cpp
......@@ -48,22 +48,6 @@ namespace YAML
}
}
// Peek
// . Peeks at the next 'n' characters and returns them in a string.
std::string Scanner::Peek(int n)
{
std::string ret;
int pos = INPUT.tellg();
for(int i=0;i<n;i++)
ret += INPUT.get();
INPUT.clear();
INPUT.seekg(pos);
return ret;
}
// GetLineBreak
// . Eats with no checking
void Scanner::EatLineBreak()
......@@ -97,7 +81,7 @@ namespace YAML
if(m_column != 0)
return false;
return Exp::DocStart.Matches(Peek(4));
return Exp::DocStart.Matches(INPUT);
}
// IsDocumentEnd
......@@ -107,41 +91,37 @@ namespace YAML
if(m_column != 0)
return false;
return Exp::DocEnd.Matches(Peek(4));
return Exp::DocEnd.Matches(INPUT);
}
// IsBlockEntry
bool Scanner::IsBlockEntry()
{
return Exp::BlockEntry.Matches(Peek(2));
return Exp::BlockEntry.Matches(INPUT);
}
// IsKey
bool Scanner::IsKey()
{
std::string next = Peek(2);
if(m_flowLevel > 0)
return Exp::KeyInFlow.Matches(next);
return Exp::Key.Matches(next);
return Exp::KeyInFlow.Matches(INPUT);
return Exp::Key.Matches(INPUT);
}
// IsValue
bool Scanner::IsValue()
{
std::string next = Peek(2);
if(m_flowLevel > 0)
return Exp::ValueInFlow.Matches(next);
return Exp::Value.Matches(next);
return Exp::ValueInFlow.Matches(INPUT);
return Exp::Value.Matches(INPUT);
}
// IsPlainScalar
// . Rules:
bool Scanner::IsPlainScalar()
{
std::string next = Peek(2);
if(m_flowLevel > 0)
return Exp::PlainScalarInFlow.Matches(next);
return Exp::PlainScalar.Matches(next);
return Exp::PlainScalarInFlow.Matches(INPUT);
return Exp::PlainScalar.Matches(INPUT);
}
///////////////////////////////////////////////////////////////////////
......@@ -368,21 +348,19 @@ namespace YAML
break;
// comment
if(Exp::Comment.Matches(INPUT.peek()))
if(Exp::Comment.Matches(INPUT))
break;
// first eat non-blanks
while(INPUT && !Exp::BlankOrBreak.Matches(INPUT.peek())) {
std::string next = Peek(2);
while(INPUT && !Exp::BlankOrBreak.Matches(INPUT)) {
// illegal colon in flow context
if(m_flowLevel > 0 && Exp::IllegalColonInScalar.Matches(next))
if(m_flowLevel > 0 && Exp::IllegalColonInScalar.Matches(INPUT))
throw IllegalScalar();
// characters that might end the scalar
if(m_flowLevel > 0 && Exp::EndScalarInFlow.Matches(next))
if(m_flowLevel > 0 && Exp::EndScalarInFlow.Matches(INPUT))
break;
if(m_flowLevel == 0 && Exp::EndScalar.Matches(next))
if(m_flowLevel == 0 && Exp::EndScalar.Matches(INPUT))
break;
if(leadingBlanks) {
......@@ -409,12 +387,12 @@ namespace YAML
}
// did we hit a non-blank character that ended us?
if(!Exp::BlankOrBreak.Matches(INPUT.peek()))
if(!Exp::BlankOrBreak.Matches(INPUT))
break;
// now eat blanks
while(INPUT && Exp::BlankOrBreak.Matches(INPUT.peek())) {
if(Exp::Blank.Matches(INPUT.peek())) {
while(INPUT && Exp::BlankOrBreak.Matches(INPUT)) {
if(Exp::Blank.Matches(INPUT)) {
if(leadingBlanks && m_column <= m_indents.top())
throw IllegalTabInScalar();
......
scanner.h
......@@ -71,8 +71,6 @@ namespace YAML
private:
char GetChar();
void Eat(int n = 1);
std::string Peek(int n);
void EatLineBreak();
bool IsWhitespaceToBeEaten(char ch);
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment