bool StringToBool(std::string const& str)
{
std::string lowerStr = str;
std::transform(str.begin(), str.end(), lowerStr.begin(), [](char c) { return char(::tolower(c)); });
return lowerStr == "1" || lowerStr == "true" || lowerStr == "yes";
}
inline unsigned int regex_grep(bool (*foo)(const match_results<std::string::const_iterator>&), const std::string& s,
const regex& e,
match_flag_type flags = match_default)
{
return regex_grep(foo, s.begin(), s.end(), e, flags);
}
std::string remove(std::string expression, const std::string& toRemove) {
for (std::string::const_iterator str = toRemove.begin(); str != toRemove.end(); str++) {
expression.erase(std::remove(expression.begin(), expression.end(), *str), expression.end());
}
return expression;
}
Time::Time(const std::string& str, const std::string& fmt)
: _msecs(0)
{
unsigned hours = 0;
unsigned minutes = 0;
unsigned seconds = 0;
unsigned mseconds = 0;
bool am = true;
enum {
state_0,
state_fmt
} state = state_0;
std::string::const_iterator dit = str.begin();
std::string::const_iterator it;
for (it = fmt.begin(); it != fmt.end(); ++it)
{
char ch = *it;
switch (state)
{
case state_0:
if (ch == '%')
state = state_fmt;
else
{
if (dit == str.end() || *dit != ch)
throw std::runtime_error("string <" + str + "> does not match time format <" + fmt + '>');
++dit;
}
break;
case state_fmt:
switch (ch)
{
case 'H':
case 'I':
hours = getUnsigned(dit, str.end(), 2);
break;
case 'M':
minutes = getUnsigned(dit, str.end(), 2);
break;
case 'S':
seconds = getUnsigned(dit, str.end(), 2);
break;
case 'j':
if (dit != str.end() && *dit == '.')
++dit;
mseconds = getMilliseconds(dit, str.end());
break;
case 'J':
case 'K':
if (dit != str.end() && *dit == '.')
{
++dit;
mseconds = getMilliseconds(dit, str.end());
}
break;
case 'k':
mseconds = getMilliseconds(dit, str.end());
break;
case 'p':
if (dit == str.end()
|| dit + 1 == str.end()
|| ((*dit != 'A'
&& *dit != 'a'
&& *dit != 'P'
&& *dit != 'p')
|| (*(dit + 1) != 'M'
&& *(dit + 1) != 'm')))
{
throw std::runtime_error("string <" + str + "> does not match time format <" + fmt + '>');
}
am = (*dit == 'A' || *dit == 'a');
dit += 2;
break;
default:
throw std::runtime_error("invalid time format <" + fmt + '>');
}
state = state_0;
break;
}
}
if (it != fmt.end() || dit != str.end())
throw std::runtime_error("string <" + str + "> does not match time format <" + fmt + '>');
set(am ? hours : hours + 12, minutes, seconds, mseconds);
}
bool is_number(const std::string& s)
{
std::string::const_iterator it = s.begin();
while (it != s.end() && (isdigit(*it))) ++it;
return !s.empty() && it == s.end();
}
void Toolbox::ToLowerCase(std::string& s)
{
std::transform(s.begin(), s.end(), s.begin(), tolower);
}
entry decode(std::string const& str)
{
return bdecode(str.begin(), str.end());
}
// returns protocol, auth, hostname, port, path
boost::tuple<std::string, std::string, std::string, int, std::string>
parse_url_components(std::string url, error_code& ec)
{
std::string hostname; // hostname only
std::string auth; // user:pass
std::string protocol; // http or https for instance
int port = -1;
std::string::iterator at;
std::string::iterator colon;
std::string::iterator port_pos;
// PARSE URL
std::string::iterator start = url.begin();
// remove white spaces in front of the url
while (start != url.end() && is_space(*start))
++start;
std::string::iterator end
= std::find(url.begin(), url.end(), ':');
protocol.assign(start, end);
if (end == url.end())
{
ec = errors::unsupported_url_protocol;
goto exit;
}
++end;
if (end == url.end() || *end != '/')
{
ec = errors::unsupported_url_protocol;
goto exit;
}
++end;
if (end == url.end() || *end != '/')
{
ec = errors::unsupported_url_protocol;
goto exit;
}
++end;
start = end;
at = std::find(start, url.end(), '@');
colon = std::find(start, url.end(), ':');
end = std::find(start, url.end(), '/');
if (at != url.end()
&& colon != url.end()
&& colon < at
&& at < end)
{
auth.assign(start, at);
start = at;
++start;
}
// this is for IPv6 addresses
if (start != url.end() && *start == '[')
{
port_pos = std::find(start, url.end(), ']');
if (port_pos == url.end())
{
ec = errors::expected_close_bracket_in_address;
goto exit;
}
port_pos = std::find(port_pos, url.end(), ':');
}
else
{
port_pos = std::find(start, url.end(), ':');
}
if (port_pos < end)
{
hostname.assign(start, port_pos);
++port_pos;
for (std::string::iterator i = port_pos; i < end; ++i)
{
if (is_digit(*i)) continue;
ec = errors::invalid_port;
goto exit;
}
port = std::atoi(std::string(port_pos, end).c_str());
}
else
{
hostname.assign(start, end);
}
start = end;
exit:
return boost::make_tuple(protocol, auth, hostname, port
, std::string(start, url.end()));
}
/**
* We don't want to pronounce punctuation
*/
void ALSpeech::replaceSymbols(std::string& text)
{
replace(text.begin(), text.end(), '_', ' ');
replace(text.begin(), text.end(), ':', ' ');
replace(text.begin(), text.end(), '-', ' ');
}
/// c'tor
Parser(std::string input_data) :
data_(input_data),
state_(data_.begin()),
error_state_(data_.begin())
{}
void Lux_OGL_DrawText( std::string text, LuxRect dest_rect, Effects image_effects, bool allow_custom )
{
//glPushMatrix();
int32_t z = dest_rect.z/1000;
glColor4ub(image_effects.colour.r, image_effects.colour.g, image_effects.colour.b, image_effects.colour.a);
uint16_t x = dest_rect.x;
std::string::iterator object;
for ( object = text.begin(); object != text.end(); object++ )
{
uint32_t cchar = *object;
/*
194-223 2 bytes
224-239 3 bytes
240-244 4 bytes
*/
if (cchar == '\n' || cchar == '\r')
{
dest_rect.y += ( oglGraphics_customtext && allow_custom ? oglGraphics_customtext_height + 2 : 10);
x = dest_rect.x;
}
else if ( cchar <= 32 )
{
x += 7;
}
else if ( cchar <= 128 )
{
if ( oglGraphics_customtext && allow_custom )
{
x += Lux_OGL_DrawChar((int32_t)cchar, x, dest_rect.y, z, image_effects);
}
else
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, font[cchar-32]);
glBegin(GL_QUADS);
glTexCoord2f( 0.0, 0.0 );
Lux_OGL_ColouredVertex3(image_effects.colour, image_effects.colour2, image_effects.style, 1, x, dest_rect.y, z);
glTexCoord2f( 1.0, 0.0 );
Lux_OGL_ColouredVertex3(image_effects.colour, image_effects.colour2, image_effects.style, 2, x + 8, dest_rect.y, z);
glTexCoord2f( 1.0, 1.0 );
Lux_OGL_ColouredVertex3(image_effects.colour, image_effects.colour2, image_effects.style, 3, x + 8, dest_rect.y + 8, z);
glTexCoord2f( 0.0, 1.0 );
Lux_OGL_ColouredVertex3(image_effects.colour, image_effects.colour2, image_effects.style, 4, x, dest_rect.y + 8, z );
glEnd();
glDisable(GL_TEXTURE_2D);
x += 7;
}
}
else
{
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, font['?'-32]);
glBegin(GL_QUADS);
glTexCoord2f( 0.0, 0.0 );
Lux_OGL_ColouredVertex3(image_effects.colour, image_effects.colour2, image_effects.style, 1, x, dest_rect.y, z);
glTexCoord2f( 1.0, 0.0 );
Lux_OGL_ColouredVertex3(image_effects.colour, image_effects.colour2, image_effects.style, 2, x + 8, dest_rect.y, z);
glTexCoord2f( 1.0, 1.0 );
Lux_OGL_ColouredVertex3(image_effects.colour, image_effects.colour2, image_effects.style, 3, x + 8, dest_rect.y + 8, z);
glTexCoord2f( 0.0, 1.0 );
Lux_OGL_ColouredVertex3(image_effects.colour, image_effects.colour2, image_effects.style, 4, x, dest_rect.y + 8, z );
glEnd();
glDisable(GL_TEXTURE_2D);
x += 7;
if ( cchar < 224 )
object++;
else if ( cchar < 240 )
object +=2;
else if ( cchar < 245 )
object +=3;
}
}
glColor4f(1.0,1.0,1.0,1.0);
//glPopMatrix();
}
void DateTimeFormatter::append(std::string& str, const DateTime& dateTime, const std::string& fmt, int timeZoneDifferential)
{
std::string::const_iterator it = fmt.begin();
std::string::const_iterator end = fmt.end();
while (it != end)
{
if (*it == '%')
{
if (++it != end)
{
switch (*it)
{
case 'w':
str.append(DateTimeFormat::WEEKDAY_NAMES[dateTime.dayOfWeek()], 0, 3);
break;
case 'W':
str.append(DateTimeFormat::WEEKDAY_NAMES[dateTime.dayOfWeek()]);
break;
case 'b':
str.append(DateTimeFormat::MONTH_NAMES[dateTime.month() - 1], 0, 3);
break;
case 'B':
str.append(DateTimeFormat::MONTH_NAMES[dateTime.month() - 1]);
break;
case 'd':
NumberFormatter::append0(str, dateTime.day(), 2);
break;
case 'e':
NumberFormatter::append(str, dateTime.day());
break;
case 'f':
NumberFormatter::append(str, dateTime.day(), 2);
break;
case 'm':
NumberFormatter::append0(str, dateTime.month(), 2);
break;
case 'n':
NumberFormatter::append(str, dateTime.month());
break;
case 'o':
NumberFormatter::append(str, dateTime.month(), 2);
break;
case 'y':
NumberFormatter::append0(str, dateTime.year() % 100, 2);
break;
case 'Y':
NumberFormatter::append0(str, dateTime.year(), 4);
break;
case 'H':
NumberFormatter::append0(str, dateTime.hour(), 2);
break;
case 'h':
NumberFormatter::append0(str, dateTime.hourAMPM(), 2);
break;
case 'a':
str.append(dateTime.isAM() ? "am" : "pm");
break;
case 'A':
str.append(dateTime.isAM() ? "AM" : "PM");
break;
case 'M':
NumberFormatter::append0(str, dateTime.minute(), 2);
break;
case 'S':
NumberFormatter::append0(str, dateTime.second(), 2);
break;
case 's':
NumberFormatter::append0(str, dateTime.second(), 2);
str += '.';
NumberFormatter::append0(str, dateTime.millisecond()*1000 + dateTime.microsecond(), 6);
break;
case 'i':
NumberFormatter::append0(str, dateTime.millisecond(), 3);
break;
case 'c':
NumberFormatter::append(str, dateTime.millisecond()/100);
break;
case 'F':
NumberFormatter::append0(str, dateTime.millisecond()*1000 + dateTime.microsecond(), 6);
break;
case 'z':
tzdISO(str, timeZoneDifferential);
break;
case 'Z':
tzdRFC(str, timeZoneDifferential);
break;
default:
str += *it;
}
++it;
}
}
else str += *it++;
}
}
explicit binary(const std::string& s) : std::vector<value_type>(s.begin(), s.end()) {}
std::string RegexSMatch::format(const std::string& s) const
{
enum state_type
{
state_0,
state_esc,
state_var0,
state_var1,
state_1
} state;
state = state_0;
std::string ret;
for (std::string::const_iterator it = s.begin(); it != s.end(); ++it)
{
char ch = *it;
switch (state)
{
case state_0:
if (ch == '$')
state = state_var0;
else if (ch == '\\')
state = state_esc;
break;
case state_esc:
ret += ch;
state = state_1;
break;
case state_var0:
if (std::isdigit(ch))
{
ret = std::string(s.begin(), it - 1);
regoff_t s = matchbuf[ch - '0'].rm_so;
regoff_t e = matchbuf[ch - '0'].rm_eo;
if (s >= 0 && e >= 0)
ret.append(str, s, e-s);
state = state_1;
}
else
state = state_0;
break;
case state_1:
if (ch == '$')
state = state_var1;
else if (state == '\\')
state = state_esc;
else
ret += ch;
break;
case state_var1:
if (std::isdigit(ch))
{
regoff_t s = matchbuf[ch - '0'].rm_so;
regoff_t e = matchbuf[ch - '0'].rm_eo;
if (s >= 0 && e >= 0)
ret.append(str, s, e-s);
state = state_1;
}
else if (ch == '$')
ret += '$';
else
{
ret += '$';
ret += ch;
}
break;
}
}
switch (state)
{
case state_0:
case state_var0:
return s;
case state_esc:
return ret + '\\';
case state_var1:
return ret + '$';
case state_1:
return ret;
}
return ret;
}
std::size_t ByteBuffer::writeBytes(const std::string& buffer)
{
_buffer.reserve(_buffer.size() + buffer.size());
_buffer.insert(_buffer.end(), buffer.begin(), buffer.end());
return buffer.size();
}
std::string glob_to_regex(const std::string& glob)
{
std::string regex;
regex.reserve(glob.size()<<1);
S32 braces = 0;
bool escaped = false;
bool square_brace_open = false;
for (std::string::const_iterator i = glob.begin(); i != glob.end(); ++i)
{
char c = *i;
switch (c)
{
case '.':
regex+="\\.";
break;
case '*':
if (glob.begin() == i)
{
regex+="[^.].*";
}
else
{
regex+= escaped ? "*" : ".*";
}
break;
case '?':
regex+= escaped ? '?' : '.';
break;
case '{':
braces++;
regex+='(';
break;
case '}':
if (!braces)
{
llerrs << "glob_to_regex: Closing brace without an equivalent opening brace: " << glob << llendl;
}
regex+=')';
braces--;
break;
case ',':
regex+= braces ? '|' : c;
break;
case '!':
regex+= square_brace_open ? '^' : c;
break;
default:
regex+=c;
break;
}
escaped = ('\\' == c);
square_brace_open = ('[' == c);
}
if (braces)
{
llerrs << "glob_to_regex: Unterminated brace expression: " << glob << llendl;
}
return regex;
}
std::size_t ByteBuffer::readBytes(std::string& buffer) const
{
buffer.resize(_buffer.size());
buffer.insert(buffer.begin(), _buffer.begin(), _buffer.end());
return buffer.size();
}
std::string reverse(std::string str)
{
// Not the most efficient way of doing this.
std::reverse(str.begin(),str.end());
return str;
}
void Parser::nextToken(unsigned line, const std::string& token, Schema& schema) {
if (getenv("DEBUG"))
std::cerr << line << ": " << token << std::endl;
if (token.empty())
return;
std::string tok;
std::transform(token.begin(), token.end(), std::back_inserter(tok), tolower);
switch(state) {
case State::Semicolon: /* fallthrough */
case State::Init:
if (tok==keyword::Create)
state=State::Create;
else
throw ParserError(line, "Expected 'CREATE', found '"+token+"'");
break;
case State::Create:
if (tok==keyword::Table)
state=State::Table;
else
throw ParserError(line, "Expected 'TABLE', found '"+token+"'");
break;
case State::Table:
if (isIdentifier(tok)) {
state=State::TableName;
if(tok.find("\"") == 0) { // For handling tableNames with quotes in SQL
std::string tokModified = tok;
tokModified.erase(tokModified.begin());
tokModified.erase(tokModified.end()-1);
schema.relations.push_back(Schema::Relation(tokModified));
} else {
schema.relations.push_back(Schema::Relation(token));
}
} else {
throw ParserError(line, "Expected TableName, found '"+token+"'");
}
break;
case State::TableName:
if (tok.size()==1 && tok[0]==literal::ParenthesisLeft)
state=State::CreateTableBegin;
else
throw ParserError(line, "Expected '(', found '"+token+"'");
break;
case State::Separator: /* fallthrough */
case State::CreateTableBegin:
if (tok.size()==1 && tok[0]==literal::ParenthesisRight) {
state=State::CreateTableEnd;
} else if (tok==keyword::Primary) {
state=State::Primary;
} else if (isIdentifier(tok)) {
schema.relations.back().attributes.push_back(Schema::Relation::Attribute());
schema.relations.back().attributes.back().name = token;
state=State::AttributeName;
} else {
throw ParserError(line, "Expected attribute definition, primary key definition or ')', found '"+token+"'");
}
break;
case State::CreateTableEnd:
if (tok.size()==1 && tok[0]==literal::Semicolon)
state=State::Semicolon;
else
throw ParserError(line, "Expected ';', found '"+token+"'");
break;
case State::Primary:
if (tok==keyword::Key)
state=State::Key;
else
throw ParserError(line, "Expected 'KEY', found '"+token+"'");
break;
case State::Key:
if (tok.size()==1 && tok[0]==literal::ParenthesisLeft)
state=State::KeyListBegin;
else
throw ParserError(line, "Expected list of key attributes, found '"+token+"'");
break;
case State::KeyListBegin:
if (isIdentifier(tok)) {
struct AttributeNamePredicate {
const std::string& name;
AttributeNamePredicate(const std::string& name) : name(name) {}
bool operator()(const Schema::Relation::Attribute& attr) const {
return attr.name == name;
}
};
const auto& attributes = schema.relations.back().attributes;
AttributeNamePredicate p(token);
auto it = std::find_if(attributes.begin(), attributes.end(), p);
if (it == attributes.end())
throw ParserError(line, "'"+token+"' is not an attribute of '"+schema.relations.back().name+"'");
schema.relations.back().primaryKey.push_back(std::distance(attributes.begin(), it));
state=State::KeyName;
} else {
throw ParserError(line, "Expected key attribute, found '"+token+"'");
}
break;
case State::KeyName:
if (tok.size()==1 && tok[0] == literal::Comma)
state=State::KeyListBegin;
else if (tok.size()==1 && tok[0] == literal::ParenthesisRight)
state=State::KeyListEnd;
else
throw ParserError(line, "Expected ',' or ')', found '"+token+"'");
break;
case State::KeyListEnd:
if (tok.size()==1 && tok[0] == literal::Comma)
state=State::Separator;
else if (tok.size()==1 && tok[0] == literal::ParenthesisRight)
state=State::CreateTableEnd;
else
throw ParserError(line, "Expected ',' or ')', found '"+token+"'");
break;
case State::AttributeName:
if (tok==keyword::Integer) {
schema.relations.back().attributes.back().type=Types::Tag::Integer;
state=State::AttributeTypeInt;
} else if (tok==keyword::Char) {
schema.relations.back().attributes.back().type=Types::Tag::Char;
state=State::AttributeTypeChar;
} else if (tok==keyword::Numeric) {
schema.relations.back().attributes.back().type=Types::Tag::Numeric;
state=State::AttributeTypeNumeric;
} else if (tok==keyword::Varchar) {
schema.relations.back().attributes.back().type=Types::Tag::Varchar;
state=State::AttributeTypeVarchar;
} else if (tok==keyword::Timestamp) {
schema.relations.back().attributes.back().type=Types::Tag::Timestamp;
state=State::AttributeTypeTimestamp;
}
else throw ParserError(line, "Expected type after attribute name, found '"+token+"'");
break;
case State::AttributeTypeChar:
if (tok.size()==1 && tok[0]==literal::ParenthesisLeft)
state=State::CharBegin;
else
throw ParserError(line, "Expected '(' after 'CHAR', found'"+token+"'");
break;
case State::CharBegin:
if (isInt(tok)) {
schema.relations.back().attributes.back().len=std::atoi(tok.c_str());
state=State::CharValue;
} else {
throw ParserError(line, "Expected integer after 'CHAR(', found'"+token+"'");
}
break;
case State::CharValue:
if (tok.size()==1 && tok[0]==literal::ParenthesisRight)
state=State::CharEnd;
else
throw ParserError(line, "Expected ')' after length of CHAR, found'"+token+"'");
break;
case State::AttributeTypeVarchar:
if (tok.size()==1 && tok[0]==literal::ParenthesisLeft)
state=State::VarcharBegin;
else
throw ParserError(line, "Expected '(' after 'VARCHAR', found'"+token+"'");
break;
case State::VarcharBegin:
if (isInt(tok)) {
schema.relations.back().attributes.back().len=std::atoi(tok.c_str());
state=State::VarcharValue;
} else {
throw ParserError(line, "Expected integer after 'VARCHAR(', found'"+token+"'");
}
break;
case State::VarcharValue:
if (tok.size()==1 && tok[0]==literal::ParenthesisRight)
state=State::VarcharEnd;
else
throw ParserError(line, "Expected ')' after length of VARCHAR, found'"+token+"'");
break;
case State::AttributeTypeNumeric:
if (tok.size()==1 && tok[0]==literal::ParenthesisLeft)
state=State::NumericBegin;
else
throw ParserError(line, "Expected '(' after 'NUMERIC', found'"+token+"'");
break;
case State::NumericBegin:
if (isInt(tok)) {
schema.relations.back().attributes.back().len1=std::atoi(tok.c_str());
state=State::NumericValue1;
} else {
throw ParserError(line, "Expected integer after 'NUMERIC(', found'"+token+"'");
}
break;
case State::NumericValue1:
if (tok.size()==1 && tok[0]==literal::Comma)
state=State::NumericSeparator;
else
throw ParserError(line, "Expected ',' after first length of NUMERIC, found'"+token+"'");
break;
case State::NumericValue2:
if (tok.size()==1 && tok[0]==literal::ParenthesisRight)
state=State::NumericEnd;
else
throw ParserError(line, "Expected ')' after second length of NUMERIC, found'"+token+"'");
break;
case State::NumericSeparator:
if (isInt(tok)) {
schema.relations.back().attributes.back().len2=std::atoi(tok.c_str());
state=State::NumericValue2;
} else {
throw ParserError(line, "Expected second length for NUMERIC type, found'"+token+"'");
}
break;
case State::CharEnd: /* fallthrough */
case State::VarcharEnd: /* fallthrough */
case State::NumericEnd: /* fallthrough */
case State::AttributeTypeInt:
if (tok.size()==1 && tok[0]==literal::Comma)
state=State::Separator;
else if (tok==keyword::Not)
state=State::Not;
else if (tok.size()==1 && tok[0]==literal::ParenthesisRight)
state=State::CreateTableEnd;
else throw ParserError(line, "Expected ',' or 'NOT NULL' after attribute type, found '"+token+"'");
break;
case State::AttributeTypeTimestamp:
if (tok.size()==1 && tok[0]==literal::Comma)
state=State::Separator;
else if (tok==keyword::Not)
state=State::Not;
else if (tok.size()==1 && tok[0]==literal::ParenthesisRight)
state=State::CreateTableEnd;
else throw ParserError(line, "Expected ',' or 'NOT NULL' after attribute type, found '"+token+"'");
break;
case State::Not:
if (tok==keyword::Null) {
schema.relations.back().attributes.back().notNull=true;
state=State::Null;
}
else throw ParserError(line, "Expected 'NULL' after 'NOT' name, found '"+token+"'");
break;
case State::Null:
if (tok.size()==1 && tok[0]==literal::Comma)
state=State::Separator;
else if (tok.size()==1 && tok[0]==literal::ParenthesisRight)
state=State::CreateTableEnd;
else throw ParserError(line, "Expected ',' or ')' after attribute definition, found '"+token+"'");
break;
default:
throw;
}
}
std::string::size_type RegularExpression::substOne(std::string& subject, std::string::size_type offset, const std::string& replacement, int options) const
{
if (offset >= subject.length()) return std::string::npos;
int ovec[OVEC_SIZE];
int rc = pcre_exec(_pcre, _extra, subject.c_str(), int(subject.size()), int(offset), options & 0xFFFF, ovec, OVEC_SIZE);
if (rc == PCRE_ERROR_NOMATCH)
{
return std::string::npos;
}
else if (rc == PCRE_ERROR_BADOPTION)
{
throw RegularExpressionException("bad option");
}
else if (rc == 0)
{
throw RegularExpressionException("too many captured substrings");
}
else if (rc < 0)
{
std::ostringstream msg;
msg << "PCRE error " << rc;
throw RegularExpressionException(msg.str());
}
std::string result;
std::string::size_type len = subject.length();
std::string::size_type pos = 0;
std::string::size_type rp = std::string::npos;
while (pos < len)
{
if (ovec[0] == pos)
{
std::string::const_iterator it = replacement.begin();
std::string::const_iterator end = replacement.end();
while (it != end)
{
if (*it == '$' && !(options & RE_NO_VARS))
{
++it;
if (it != end)
{
char d = *it;
if (d >= '0' && d <= '9')
{
int c = d - '0';
if (c < rc)
{
int o = ovec[c*2];
int l = ovec[c*2 + 1] - o;
result.append(subject, o, l);
}
}
else
{
result += '$';
result += d;
}
++it;
}
else result += '$';
}
else result += *it++;
}
pos = ovec[1];
rp = result.length();
}
else result += subject[pos++];
}
subject = result;
return rp;
}
std::string Time::toString(const std::string& fmt) const
{
unsigned hours, minutes, seconds, mseconds;
get(hours, minutes, seconds, mseconds);
std::string str;
enum {
state_0,
state_fmt
} state = state_0;
for (std::string::const_iterator it = fmt.begin(); it != fmt.end(); ++it)
{
switch (state)
{
case state_0:
if (*it == '%')
state = state_fmt;
else
str += *it;
break;
case state_fmt:
switch (*it)
{
case 'H': appendD2(str, hours); break;
case 'I': appendD2(str, hours % 12); break;
case 'M': appendD2(str, minutes); break;
case 'S': appendD2(str, seconds); break;
case 'j': if (mseconds != 0)
{
str += '.';
str += (mseconds / 100 + '0');
if (mseconds % 100 != 0)
{
str += (mseconds / 10 % 10 + '0');
if (mseconds % 10 != 0)
str += (mseconds % 10 + '0');
}
}
break;
case 'J': str += '.';
str += (mseconds / 100 + '0');
if (mseconds % 100 != 0)
{
str += (mseconds / 10 % 10 + '0');
if (mseconds % 10 != 0)
str += (mseconds % 10 + '0');
}
break;
case 'k': appendD3(str, mseconds);
break;
case 'K': str += '.';
appendD3(str, mseconds);
break;
case 'p': str += (hours < 12 ? "am" : "pm"); break;
case 'P': str += (hours < 12 ? "AM" : "PM"); break;
default:
str += '%';
}
if (*it != '%')
state = state_0;
break;
}
}
if (state == state_fmt)
str += '%';
return str;
}
void TrimLeft(std::string& s)
{
s.erase(s.begin(),
std::find_if(s.begin(), s.end(), std::not1(IsDigit())));
}
std::wstring StringToWString(const std::string& s)
{
std::wstring temp(s.length(),L' ');
std::copy(s.begin(), s.end(), temp.begin());
return temp;
}
bool is_number(const std::string& s) {
return !s.empty()
&& std::find_if(s.begin(), s.end(),
[](char c) { return !std::isdigit(c); }) == s.end();
}
void RemoveSubStr(std::string& sInput, const std::string& sub)
{
std::string::size_type foundpos = sInput.find(sub);
if ( foundpos != std::string::npos )
sInput.erase(sInput.begin() + foundpos, sInput.begin() + foundpos + sub.length());
}
/**
* formatiert einen Zeitstring.
*
* @param[in] format Formatstring (%Y=4 stelliges Jahr, %m 2 stelliges Monat, %D tag, %H Stunde, %i Minute, %s Sekunden)
* @param[in] time zu benutzender Timestamp.
*
* @return Formatted string
*/
std::string Time::FormatTime(const std::string& format, unser_time_t* time)
{
time_t inTime;
if(time)
inTime = *time;
else
inTime = CurrentTime();
tm* time_data = localtime(&inTime);
if(!time_data)
return "";
using std::setw;
std::stringstream res;
res << std::setfill('0');
bool isInFormat = false;
for(std::string::const_iterator c = format.begin(); c != format.end(); ++c)
{
if(isInFormat)
{
isInFormat = false;
switch(*c)
{
case 'Y':
res << setw(4) << (1900 + time_data->tm_year);
break;
case 'm':
res << setw(2) << (time_data->tm_mon+1);
break;
case 'd':
res << setw(2) << time_data->tm_mday;
break;
case 'H':
res << setw(2) << time_data->tm_hour;
break;
case 'i':
res << setw(2) << time_data->tm_min;
break;
case 's':
res << setw(2) << time_data->tm_sec;
break;
case '%':
res << '%';
break;
default:
std::cerr << "Invalid format string: " << format << std::endl;
res << *c;
break;
}
}else if(*c == '%')
isInFormat = true;
else
res << *c;
}
if(isInFormat)
std::cerr << "Invalid format string: " << format << std::endl;
return res.str();
}
bool BinaryExpParser::checkExpression(std::string& strexp)
{
ErrorLogger* logger = ErrorLogger::Instance();
if(std::count(strexp.begin(), strexp.end(), '(') !=
std::count(strexp.begin(), strexp.end(), ')'))
{
logger->addError("Incorrect expression format! (parentheses do not match)");
return false;
}
if(std::count(strexp.begin(), strexp.end(), IMPLY) != 1 )
{
logger->addError("Incorrect expression format! (no implication ':' found)");
return false;
}
// erassing all the sapces
strexp.erase(std::remove_if(strexp.begin(), strexp.end(), ::isspace), strexp.end());
if(!strexp.size())
{
logger->addError("Empty expression!");
return false;
}
// making a copy of strexp and checking more
string dummy = strexp;
// removing all pranteses
dummy.erase(std::remove_if(dummy.begin(), dummy.end(), isParentheses), dummy.end());
leftOpr = dummy.substr(0, dummy.find(IMPLY));
if(!leftOpr.size())
{
logger->addError("Missing operand before ':'");
return false;
}
if(dummy.find(IMPLY) == (dummy.size()-1))
{
logger->addError("Missing operands after ':'");
return false;
}
dummy.erase(0, dummy.find(IMPLY)+1);
if(dummy.find(leftOpr) != string::npos)
{
std::string msg;
msg = "recursive assignment of operand '" + leftOpr + "'";
logger->addError(msg.c_str());
return false;
}
// checking '~'
size_t n = dummy.find(EXPNOT);
while(n != string::npos)
{
OSTRINGSTREAM msg;
bool bError = ((n+1) == dummy.length()); // empty operand after ~
if((n+1) < dummy.length())
{
bError |= (dummy[n+1] == EXPAND); // operator & after ~
bError |= (dummy[n+1] == EXPOR); // operand | after ~
}
if(n != 0)
bError |= (dummy[n-1] != EXPAND) && (dummy[n-1] != EXPOR); // an operand before ~
if(bError)
{
msg<<"Incorrect expression format of '~' at "<<(int)n;
logger->addError(msg.str().c_str());
return false;
}
n = dummy.find(EXPNOT, n+1);
}
// checking '| &'
n = dummy.find_first_of("&|");
while(n != string::npos)
{
OSTRINGSTREAM msg;
bool bError = ((n+1) == dummy.length()); // empty operand after & or |
if((n+1) < dummy.length())
{
bError |= (dummy[n+1] == EXPAND); // operator & after & or |
bError |= (dummy[n+1] == EXPOR); // operand | after & or |
}
bError |= (n == 0); // empty operand before & or |
if(n != 0)
{
bError |= (dummy[n-1] == EXPAND); // operator & before & or |
bError |= (dummy[n-1] == EXPOR); // operand | before & or |
bError |= (dummy[n-1] == EXPOR); // operand ~ before & or |
}
if(bError)
{
msg<<"Incorrect expression format of '&' or '|' at "<<(int)n;
logger->addError(msg.str().c_str());
return false;
}
n = dummy.find_first_of("&|", n+1);
}
// at the end
strexp.erase(0, strexp.find(IMPLY)+1);
return true;
}
inline bool headers_equal(const std::string &a, const std::string &b)
{
if (a.length() != b.length())
return false;
return std::equal(a.begin(), a.end(), b.begin(), tolower_compare);
}
//---------------------------------------------------------------------------
//From http://www.richelbilderbeek.nl/CppStrToLower.htm
const std::string StrToLower(std::string s)
{
std::transform(s.begin(), s.end(), s.begin(),std::ptr_fun<int,int>(std::tolower));
return s;
}
/**
* @brief method to render tags with a given map
*
* @param tmplate template std::string to render
* @param ctx map of values
*
* @return rendered std::string
*/
std::string template_t::render_tags(const std::string& tmplate,
const Context& ctx)
{
// initialize data
std::string ret = "";
std::string rest = "";
std::string::const_iterator start, end;
boost::match_results<std::string::const_iterator> matches;
start = tmplate.begin();
end = tmplate.end();
// return whole std::string when no tags are found
if (!regex_search(start, end, matches, tag,
boost::match_default | boost::format_all))
{
ret = tmplate;
}
// loop through tags and replace
while (regex_search(start, end, matches, tag,
boost::match_default | boost::format_all))
{
std::string modifier(matches[1].first, matches[1].second);
std::string key(matches[2].first, matches[2].second);
boost::algorithm::trim(key);
boost::algorithm::trim(modifier);
std::string text(start, matches[0].second);
std::string repl;
// don't html escape this
if (modifier == "&" || modifier == "{")
{
try
{
repl.assign(ctx.get(key)[0][key]);
}
catch(int i) { repl.assign(""); }
}
// this is a comment
else if (modifier == "!")
{
repl.assign("");
}
// found a partial
else if (modifier == ">")
{
std::string partial = template_t::get_partial(key);
repl.assign(template_t::render(partial, ctx));
}
// normal tag
else
{
try
{
repl.assign(template_t::html_escape(ctx.get(key)[0][key]));
}
catch(int i) { repl.assign(""); }
}
// replace
ret += boost::regex_replace(text, tag, repl,
boost::match_default | boost::format_all | boost::regex_constants::format_literal);
// change delimiter after was removed
if (modifier == "=")
{
// regex for finding delimiters
boost::regex delim("(.+?) (.+?)=");
// match object
boost::match_results<std::string::const_iterator> delim_m;
// search for the delimiters
boost::regex_search(matches[2].first, matches[2].second, delim_m, delim,
boost::match_default | boost::format_all);
// set new otag and ctag
std::string new_otag = delim_m[1];
std::string new_ctag = delim_m[2];
// change delimiters
template_t::change_delimiter(new_otag, new_ctag);
}
// set start for next tag and rest of std::string
rest.assign(matches[0].second, end);
start = matches[0].second;
}
// append and return
ret += rest;
return ret;
}