This source file includes following definitions.
- Init
- Compile
- Replace
- GlobalReplace
- Extract
- QuoteMeta
- HitLimit
- ClearHitLimit
- TryMatch
- DoMatchImpl
- DoMatch
- Rewrite
- CheckRewriteString
- NumberOfCapturingGroups
- parse_null
- parse_string
- parse_stringpiece
- parse_char
- parse_uchar
- TerminateNumber
- parse_long_radix
- parse_ulong_radix
- parse_short_radix
- parse_ushort_radix
- parse_int_radix
- parse_uint_radix
- parse_longlong_radix
- parse_ulonglong_radix
- parse_double
- parse_float
#include <errno.h>
#include "util/util.h"
#include "util/flags.h"
#include "util/pcre.h"
#ifdef WIN32
#define strtoll _strtoi64
#define strtoull _strtoui64
#endif
#define PCREPORT(level) LOG(level)
DEFINE_int32(regexp_stack_limit, 256<<10, "default PCRE stack limit (bytes)");
DEFINE_int32(regexp_match_limit, 1000000,
"default PCRE match limit (function calls)");
namespace re2 {
static const int kMaxArgs = 16;
static const int kVecSize = (1 + kMaxArgs) * 3;
static const int kPCREFrameSize = 700;
PCRE::Arg PCRE::no_more_args((void*)NULL);
const PCRE::PartialMatchFunctor PCRE::PartialMatch = { };
const PCRE::FullMatchFunctor PCRE::FullMatch = { } ;
const PCRE::ConsumeFunctor PCRE::Consume = { };
const PCRE::FindAndConsumeFunctor PCRE::FindAndConsume = { };
static const string empty_string;
void PCRE::Init(const char* pattern, Option options, int match_limit,
int stack_limit, bool report_errors) {
pattern_ = pattern;
options_ = options;
match_limit_ = match_limit;
stack_limit_ = stack_limit;
hit_limit_ = false;
error_ = &empty_string;
report_errors_ = report_errors;
re_full_ = NULL;
re_partial_ = NULL;
if (options & ~(EnabledCompileOptions | EnabledExecOptions)) {
error_ = new string("illegal regexp option");
PCREPORT(ERROR)
<< "Error compiling '" << pattern << "': illegal regexp option";
} else {
re_partial_ = Compile(UNANCHORED);
if (re_partial_ != NULL) {
re_full_ = Compile(ANCHOR_BOTH);
}
}
}
PCRE::PCRE(const char* pattern) {
Init(pattern, None, 0, 0, true);
}
PCRE::PCRE(const char* pattern, Option option) {
Init(pattern, option, 0, 0, true);
}
PCRE::PCRE(const string& pattern) {
Init(pattern.c_str(), None, 0, 0, true);
}
PCRE::PCRE(const string& pattern, Option option) {
Init(pattern.c_str(), option, 0, 0, true);
}
PCRE::PCRE(const string& pattern, const PCRE_Options& re_option) {
Init(pattern.c_str(), re_option.option(), re_option.match_limit(),
re_option.stack_limit(), re_option.report_errors());
}
PCRE::PCRE(const char *pattern, const PCRE_Options& re_option) {
Init(pattern, re_option.option(), re_option.match_limit(),
re_option.stack_limit(), re_option.report_errors());
}
PCRE::~PCRE() {
if (re_full_ != NULL) pcre_free(re_full_);
if (re_partial_ != NULL) pcre_free(re_partial_);
if (error_ != &empty_string) delete error_;
}
pcre* PCRE::Compile(Anchor anchor) {
const char* error;
int eoffset;
pcre* re;
if (anchor != ANCHOR_BOTH) {
re = pcre_compile(pattern_.c_str(),
(options_ & EnabledCompileOptions),
&error, &eoffset, NULL);
} else {
string wrapped = "(?:";
wrapped += pattern_;
wrapped += ")\\z";
re = pcre_compile(wrapped.c_str(),
(options_ & EnabledCompileOptions),
&error, &eoffset, NULL);
}
if (re == NULL) {
if (error_ == &empty_string) error_ = new string(error);
PCREPORT(ERROR) << "Error compiling '" << pattern_ << "': " << error;
}
return re;
}
bool PCRE::FullMatchFunctor::operator ()(const StringPiece& text,
const PCRE& re,
const Arg& a0,
const Arg& a1,
const Arg& a2,
const Arg& a3,
const Arg& a4,
const Arg& a5,
const Arg& a6,
const Arg& a7,
const Arg& a8,
const Arg& a9,
const Arg& a10,
const Arg& a11,
const Arg& a12,
const Arg& a13,
const Arg& a14,
const Arg& a15) const {
const Arg* args[kMaxArgs];
int n = 0;
if (&a0 == &no_more_args) goto done; args[n++] = &a0;
if (&a1 == &no_more_args) goto done; args[n++] = &a1;
if (&a2 == &no_more_args) goto done; args[n++] = &a2;
if (&a3 == &no_more_args) goto done; args[n++] = &a3;
if (&a4 == &no_more_args) goto done; args[n++] = &a4;
if (&a5 == &no_more_args) goto done; args[n++] = &a5;
if (&a6 == &no_more_args) goto done; args[n++] = &a6;
if (&a7 == &no_more_args) goto done; args[n++] = &a7;
if (&a8 == &no_more_args) goto done; args[n++] = &a8;
if (&a9 == &no_more_args) goto done; args[n++] = &a9;
if (&a10 == &no_more_args) goto done; args[n++] = &a10;
if (&a11 == &no_more_args) goto done; args[n++] = &a11;
if (&a12 == &no_more_args) goto done; args[n++] = &a12;
if (&a13 == &no_more_args) goto done; args[n++] = &a13;
if (&a14 == &no_more_args) goto done; args[n++] = &a14;
if (&a15 == &no_more_args) goto done; args[n++] = &a15;
done:
int consumed;
int vec[kVecSize];
return re.DoMatchImpl(text, ANCHOR_BOTH, &consumed, args, n, vec, kVecSize);
}
bool PCRE::PartialMatchFunctor::operator ()(const StringPiece& text,
const PCRE& re,
const Arg& a0,
const Arg& a1,
const Arg& a2,
const Arg& a3,
const Arg& a4,
const Arg& a5,
const Arg& a6,
const Arg& a7,
const Arg& a8,
const Arg& a9,
const Arg& a10,
const Arg& a11,
const Arg& a12,
const Arg& a13,
const Arg& a14,
const Arg& a15) const {
const Arg* args[kMaxArgs];
int n = 0;
if (&a0 == &no_more_args) goto done; args[n++] = &a0;
if (&a1 == &no_more_args) goto done; args[n++] = &a1;
if (&a2 == &no_more_args) goto done; args[n++] = &a2;
if (&a3 == &no_more_args) goto done; args[n++] = &a3;
if (&a4 == &no_more_args) goto done; args[n++] = &a4;
if (&a5 == &no_more_args) goto done; args[n++] = &a5;
if (&a6 == &no_more_args) goto done; args[n++] = &a6;
if (&a7 == &no_more_args) goto done; args[n++] = &a7;
if (&a8 == &no_more_args) goto done; args[n++] = &a8;
if (&a9 == &no_more_args) goto done; args[n++] = &a9;
if (&a10 == &no_more_args) goto done; args[n++] = &a10;
if (&a11 == &no_more_args) goto done; args[n++] = &a11;
if (&a12 == &no_more_args) goto done; args[n++] = &a12;
if (&a13 == &no_more_args) goto done; args[n++] = &a13;
if (&a14 == &no_more_args) goto done; args[n++] = &a14;
if (&a15 == &no_more_args) goto done; args[n++] = &a15;
done:
int consumed;
int vec[kVecSize];
return re.DoMatchImpl(text, UNANCHORED, &consumed, args, n, vec, kVecSize);
}
bool PCRE::ConsumeFunctor::operator ()(StringPiece* input,
const PCRE& pattern,
const Arg& a0,
const Arg& a1,
const Arg& a2,
const Arg& a3,
const Arg& a4,
const Arg& a5,
const Arg& a6,
const Arg& a7,
const Arg& a8,
const Arg& a9,
const Arg& a10,
const Arg& a11,
const Arg& a12,
const Arg& a13,
const Arg& a14,
const Arg& a15) const {
const Arg* args[kMaxArgs];
int n = 0;
if (&a0 == &no_more_args) goto done; args[n++] = &a0;
if (&a1 == &no_more_args) goto done; args[n++] = &a1;
if (&a2 == &no_more_args) goto done; args[n++] = &a2;
if (&a3 == &no_more_args) goto done; args[n++] = &a3;
if (&a4 == &no_more_args) goto done; args[n++] = &a4;
if (&a5 == &no_more_args) goto done; args[n++] = &a5;
if (&a6 == &no_more_args) goto done; args[n++] = &a6;
if (&a7 == &no_more_args) goto done; args[n++] = &a7;
if (&a8 == &no_more_args) goto done; args[n++] = &a8;
if (&a9 == &no_more_args) goto done; args[n++] = &a9;
if (&a10 == &no_more_args) goto done; args[n++] = &a10;
if (&a11 == &no_more_args) goto done; args[n++] = &a11;
if (&a12 == &no_more_args) goto done; args[n++] = &a12;
if (&a13 == &no_more_args) goto done; args[n++] = &a13;
if (&a14 == &no_more_args) goto done; args[n++] = &a14;
if (&a15 == &no_more_args) goto done; args[n++] = &a15;
done:
int consumed;
int vec[kVecSize];
if (pattern.DoMatchImpl(*input, ANCHOR_START, &consumed,
args, n, vec, kVecSize)) {
input->remove_prefix(consumed);
return true;
} else {
return false;
}
}
bool PCRE::FindAndConsumeFunctor::operator ()(StringPiece* input,
const PCRE& pattern,
const Arg& a0,
const Arg& a1,
const Arg& a2,
const Arg& a3,
const Arg& a4,
const Arg& a5,
const Arg& a6,
const Arg& a7,
const Arg& a8,
const Arg& a9,
const Arg& a10,
const Arg& a11,
const Arg& a12,
const Arg& a13,
const Arg& a14,
const Arg& a15) const {
const Arg* args[kMaxArgs];
int n = 0;
if (&a0 == &no_more_args) goto done; args[n++] = &a0;
if (&a1 == &no_more_args) goto done; args[n++] = &a1;
if (&a2 == &no_more_args) goto done; args[n++] = &a2;
if (&a3 == &no_more_args) goto done; args[n++] = &a3;
if (&a4 == &no_more_args) goto done; args[n++] = &a4;
if (&a5 == &no_more_args) goto done; args[n++] = &a5;
if (&a6 == &no_more_args) goto done; args[n++] = &a6;
if (&a7 == &no_more_args) goto done; args[n++] = &a7;
if (&a8 == &no_more_args) goto done; args[n++] = &a8;
if (&a9 == &no_more_args) goto done; args[n++] = &a9;
if (&a10 == &no_more_args) goto done; args[n++] = &a10;
if (&a11 == &no_more_args) goto done; args[n++] = &a11;
if (&a12 == &no_more_args) goto done; args[n++] = &a12;
if (&a13 == &no_more_args) goto done; args[n++] = &a13;
if (&a14 == &no_more_args) goto done; args[n++] = &a14;
if (&a15 == &no_more_args) goto done; args[n++] = &a15;
done:
int consumed;
int vec[kVecSize];
if (pattern.DoMatchImpl(*input, UNANCHORED, &consumed,
args, n, vec, kVecSize)) {
input->remove_prefix(consumed);
return true;
} else {
return false;
}
}
bool PCRE::Replace(string *str,
const PCRE& pattern,
const StringPiece& rewrite) {
int vec[kVecSize];
int matches = pattern.TryMatch(*str, 0, UNANCHORED, true, vec, kVecSize);
if (matches == 0)
return false;
string s;
if (!pattern.Rewrite(&s, rewrite, *str, vec, matches))
return false;
assert(vec[0] >= 0);
assert(vec[1] >= 0);
str->replace(vec[0], vec[1] - vec[0], s);
return true;
}
int PCRE::GlobalReplace(string *str,
const PCRE& pattern,
const StringPiece& rewrite) {
int count = 0;
int vec[kVecSize];
string out;
int start = 0;
bool last_match_was_empty_string = false;
for (; start <= str->length();) {
int matches;
if (last_match_was_empty_string) {
matches = pattern.TryMatch(*str, start, ANCHOR_START, false,
vec, kVecSize);
if (matches <= 0) {
if (start < str->length())
out.push_back((*str)[start]);
start++;
last_match_was_empty_string = false;
continue;
}
} else {
matches = pattern.TryMatch(*str, start, UNANCHORED, true, vec, kVecSize);
if (matches <= 0)
break;
}
int matchstart = vec[0], matchend = vec[1];
assert(matchstart >= start);
assert(matchend >= matchstart);
out.append(*str, start, matchstart - start);
pattern.Rewrite(&out, rewrite, *str, vec, matches);
start = matchend;
count++;
last_match_was_empty_string = (matchstart == matchend);
}
if (count == 0)
return 0;
if (start < str->length())
out.append(*str, start, str->length() - start);
swap(out, *str);
return count;
}
bool PCRE::Extract(const StringPiece &text,
const PCRE& pattern,
const StringPiece &rewrite,
string *out) {
int vec[kVecSize];
int matches = pattern.TryMatch(text, 0, UNANCHORED, true, vec, kVecSize);
if (matches == 0)
return false;
out->clear();
return pattern.Rewrite(out, rewrite, text, vec, matches);
}
string PCRE::QuoteMeta(const StringPiece& unquoted) {
string result;
result.reserve(unquoted.size() << 1);
for (int ii = 0; ii < unquoted.length(); ++ii) {
if ((unquoted[ii] < 'a' || unquoted[ii] > 'z') &&
(unquoted[ii] < 'A' || unquoted[ii] > 'Z') &&
(unquoted[ii] < '0' || unquoted[ii] > '9') &&
unquoted[ii] != '_' &&
!(unquoted[ii] & 128)) {
if (unquoted[ii] == '\0') {
result += "\\x00";
continue;
}
result += '\\';
}
result += unquoted[ii];
}
return result;
}
bool PCRE::HitLimit() {
return hit_limit_;
}
void PCRE::ClearHitLimit() {
hit_limit_ = 0;
}
int PCRE::TryMatch(const StringPiece& text,
int startpos,
Anchor anchor,
bool empty_ok,
int *vec,
int vecsize) const {
pcre* re = (anchor == ANCHOR_BOTH) ? re_full_ : re_partial_;
if (re == NULL) {
PCREPORT(ERROR) << "Matching against invalid re: " << *error_;
return 0;
}
int match_limit = match_limit_;
if (match_limit <= 0) {
match_limit = FLAGS_regexp_match_limit;
}
int stack_limit = stack_limit_;
if (stack_limit <= 0) {
stack_limit = FLAGS_regexp_stack_limit;
}
pcre_extra extra = { 0 };
if (match_limit > 0) {
extra.flags |= PCRE_EXTRA_MATCH_LIMIT;
extra.match_limit = match_limit;
}
if (stack_limit > 0) {
extra.flags |= PCRE_EXTRA_MATCH_LIMIT_RECURSION;
extra.match_limit_recursion = stack_limit / kPCREFrameSize;
}
int options = 0;
if (anchor != UNANCHORED)
options |= PCRE_ANCHORED;
if (!empty_ok)
options |= PCRE_NOTEMPTY;
int rc = pcre_exec(re,
&extra,
(text.data() == NULL) ? "" : text.data(),
text.size(),
startpos,
options,
vec,
vecsize);
if (rc == 0) {
rc = vecsize / 2;
} else if (rc < 0) {
switch (rc) {
case PCRE_ERROR_NOMATCH:
return 0;
case PCRE_ERROR_MATCHLIMIT:
hit_limit_ = true;
PCREPORT(WARNING) << "Exceeded match limit of " << match_limit
<< " when matching '" << pattern_ << "'"
<< " against text that is " << text.size() << " bytes.";
return 0;
case PCRE_ERROR_RECURSIONLIMIT:
hit_limit_ = true;
PCREPORT(WARNING) << "Exceeded stack limit of " << stack_limit
<< " when matching '" << pattern_ << "'"
<< " against text that is " << text.size() << " bytes.";
return 0;
default:
PCREPORT(ERROR) << "Unexpected return code: " << rc
<< " when matching '" << pattern_ << "'"
<< ", re=" << re
<< ", text=" << text
<< ", vec=" << vec
<< ", vecsize=" << vecsize;
return 0;
}
}
return rc;
}
bool PCRE::DoMatchImpl(const StringPiece& text,
Anchor anchor,
int* consumed,
const Arg* const* args,
int n,
int* vec,
int vecsize) const {
assert((1 + n) * 3 <= vecsize);
int matches = TryMatch(text, 0, anchor, true, vec, vecsize);
assert(matches >= 0);
if (matches == 0)
return false;
*consumed = vec[1];
if (n == 0 || args == NULL) {
return true;
}
if (NumberOfCapturingGroups() < n) {
return false;
}
for (int i = 0; i < n; i++) {
const int start = vec[2*(i+1)];
const int limit = vec[2*(i+1)+1];
if (!args[i]->Parse(text.data() + start, limit-start)) {
return false;
}
}
return true;
}
bool PCRE::DoMatch(const StringPiece& text,
Anchor anchor,
int* consumed,
const Arg* const args[],
int n) const {
assert(n >= 0);
size_t const vecsize = (1 + n) * 3;
int *vec = new int[vecsize];
bool b = DoMatchImpl(text, anchor, consumed, args, n, vec, vecsize);
delete[] vec;
return b;
}
bool PCRE::Rewrite(string *out, const StringPiece &rewrite,
const StringPiece &text, int *vec, int veclen) const {
int number_of_capturing_groups = NumberOfCapturingGroups();
for (const char *s = rewrite.data(), *end = s + rewrite.size();
s < end; s++) {
int c = *s;
if (c == '\\') {
c = *++s;
if (isdigit(c)) {
int n = (c - '0');
if (n >= veclen) {
if (n <= number_of_capturing_groups) {
} else {
PCREPORT(ERROR) << "requested group " << n
<< " in regexp " << rewrite.data();
return false;
}
}
int start = vec[2 * n];
if (start >= 0)
out->append(text.data() + start, vec[2 * n + 1] - start);
} else if (c == '\\') {
out->push_back('\\');
} else {
PCREPORT(ERROR) << "invalid rewrite pattern: " << rewrite.data();
return false;
}
} else {
out->push_back(c);
}
}
return true;
}
bool PCRE::CheckRewriteString(const StringPiece& rewrite, string* error) const {
int max_token = -1;
for (const char *s = rewrite.data(), *end = s + rewrite.size();
s < end; s++) {
int c = *s;
if (c != '\\') {
continue;
}
if (++s == end) {
*error = "Rewrite schema error: '\\' not allowed at end.";
return false;
}
c = *s;
if (c == '\\') {
continue;
}
if (!isdigit(c)) {
*error = "Rewrite schema error: "
"'\\' must be followed by a digit or '\\'.";
return false;
}
int n = (c - '0');
if (max_token < n) {
max_token = n;
}
}
if (max_token > NumberOfCapturingGroups()) {
SStringPrintf(error, "Rewrite schema requests %d matches, "
"but the regexp only has %d parenthesized subexpressions.",
max_token, NumberOfCapturingGroups());
return false;
}
return true;
}
int PCRE::NumberOfCapturingGroups() const {
if (re_partial_ == NULL) return -1;
int result;
CHECK(pcre_fullinfo(re_partial_,
NULL,
PCRE_INFO_CAPTURECOUNT,
&result) == 0);
return result;
}
bool PCRE::Arg::parse_null(const char* str, int n, void* dest) {
return (dest == NULL);
}
bool PCRE::Arg::parse_string(const char* str, int n, void* dest) {
if (dest == NULL) return true;
reinterpret_cast<string*>(dest)->assign(str, n);
return true;
}
bool PCRE::Arg::parse_stringpiece(const char* str, int n, void* dest) {
if (dest == NULL) return true;
reinterpret_cast<StringPiece*>(dest)->set(str, n);
return true;
}
bool PCRE::Arg::parse_char(const char* str, int n, void* dest) {
if (n != 1) return false;
if (dest == NULL) return true;
*(reinterpret_cast<char*>(dest)) = str[0];
return true;
}
bool PCRE::Arg::parse_uchar(const char* str, int n, void* dest) {
if (n != 1) return false;
if (dest == NULL) return true;
*(reinterpret_cast<unsigned char*>(dest)) = str[0];
return true;
}
static const int kMaxNumberLength = 32;
static const char* TerminateNumber(char* buf, const char* str, int n) {
if ((n > 0) && isspace(*str)) {
return "";
}
if (isdigit(str[n]) ||
((str[n] >= 'a') && (str[n] <= 'f')) ||
((str[n] >= 'A') && (str[n] <= 'F'))) {
if (n > kMaxNumberLength) return "";
memcpy(buf, str, n);
buf[n] = '\0';
return buf;
} else {
return str;
}
}
bool PCRE::Arg::parse_long_radix(const char* str,
int n,
void* dest,
int radix) {
if (n == 0) return false;
char buf[kMaxNumberLength+1];
str = TerminateNumber(buf, str, n);
char* end;
errno = 0;
long r = strtol(str, &end, radix);
if (end != str + n) return false;
if (errno) return false;
if (dest == NULL) return true;
*(reinterpret_cast<long*>(dest)) = r;
return true;
}
bool PCRE::Arg::parse_ulong_radix(const char* str,
int n,
void* dest,
int radix) {
if (n == 0) return false;
char buf[kMaxNumberLength+1];
str = TerminateNumber(buf, str, n);
if (str[0] == '-') {
return false;
}
char* end;
errno = 0;
unsigned long r = strtoul(str, &end, radix);
if (end != str + n) return false;
if (errno) return false;
if (dest == NULL) return true;
*(reinterpret_cast<unsigned long*>(dest)) = r;
return true;
}
bool PCRE::Arg::parse_short_radix(const char* str,
int n,
void* dest,
int radix) {
long r;
if (!parse_long_radix(str, n, &r, radix)) return false;
if ((short)r != r) return false;
if (dest == NULL) return true;
*(reinterpret_cast<short*>(dest)) = r;
return true;
}
bool PCRE::Arg::parse_ushort_radix(const char* str,
int n,
void* dest,
int radix) {
unsigned long r;
if (!parse_ulong_radix(str, n, &r, radix)) return false;
if ((ushort)r != r) return false;
if (dest == NULL) return true;
*(reinterpret_cast<unsigned short*>(dest)) = r;
return true;
}
bool PCRE::Arg::parse_int_radix(const char* str,
int n,
void* dest,
int radix) {
long r;
if (!parse_long_radix(str, n, &r, radix)) return false;
if ((int)r != r) return false;
if (dest == NULL) return true;
*(reinterpret_cast<int*>(dest)) = r;
return true;
}
bool PCRE::Arg::parse_uint_radix(const char* str,
int n,
void* dest,
int radix) {
unsigned long r;
if (!parse_ulong_radix(str, n, &r, radix)) return false;
if ((uint)r != r) return false;
if (dest == NULL) return true;
*(reinterpret_cast<unsigned int*>(dest)) = r;
return true;
}
bool PCRE::Arg::parse_longlong_radix(const char* str,
int n,
void* dest,
int radix) {
if (n == 0) return false;
char buf[kMaxNumberLength+1];
str = TerminateNumber(buf, str, n);
char* end;
errno = 0;
int64 r = strtoll(str, &end, radix);
if (end != str + n) return false;
if (errno) return false;
if (dest == NULL) return true;
*(reinterpret_cast<int64*>(dest)) = r;
return true;
}
bool PCRE::Arg::parse_ulonglong_radix(const char* str,
int n,
void* dest,
int radix) {
if (n == 0) return false;
char buf[kMaxNumberLength+1];
str = TerminateNumber(buf, str, n);
if (str[0] == '-') {
return false;
}
char* end;
errno = 0;
uint64 r = strtoull(str, &end, radix);
if (end != str + n) return false;
if (errno) return false;
if (dest == NULL) return true;
*(reinterpret_cast<uint64*>(dest)) = r;
return true;
}
bool PCRE::Arg::parse_double(const char* str, int n, void* dest) {
if (n == 0) return false;
static const int kMaxLength = 200;
char buf[kMaxLength];
if (n >= kMaxLength) return false;
memcpy(buf, str, n);
buf[n] = '\0';
errno = 0;
char* end;
double r = strtod(buf, &end);
if (end != buf + n) {
#ifdef COMPILER_MSVC
bool pos = true;
const char* i = buf;
if ('-' == *i) {
pos = false;
++i;
} else if ('+' == *i) {
++i;
}
if (0 == stricmp(i, "inf") || 0 == stricmp(i, "infinity")) {
r = numeric_limits<double>::infinity();
if (!pos)
r = -r;
} else if (0 == stricmp(i, "nan")) {
r = numeric_limits<double>::quiet_NaN();
} else {
return false;
}
#else
return false;
#endif
}
if (errno) return false;
if (dest == NULL) return true;
*(reinterpret_cast<double*>(dest)) = r;
return true;
}
bool PCRE::Arg::parse_float(const char* str, int n, void* dest) {
double r;
if (!parse_double(str, n, &r)) return false;
if (dest == NULL) return true;
*(reinterpret_cast<float*>(dest)) = static_cast<float>(r);
return true;
}
#define DEFINE_INTEGER_PARSERS(name) \
bool PCRE::Arg::parse_##name(const char* str, int n, void* dest) { \
return parse_##name##_radix(str, n, dest, 10); \
} \
bool PCRE::Arg::parse_##name##_hex(const char* str, int n, void* dest) { \
return parse_##name##_radix(str, n, dest, 16); \
} \
bool PCRE::Arg::parse_##name##_octal(const char* str, int n, void* dest) { \
return parse_##name##_radix(str, n, dest, 8); \
} \
bool PCRE::Arg::parse_##name##_cradix(const char* str, int n, void* dest) { \
return parse_##name##_radix(str, n, dest, 0); \
}
DEFINE_INTEGER_PARSERS(short);
DEFINE_INTEGER_PARSERS(ushort);
DEFINE_INTEGER_PARSERS(int);
DEFINE_INTEGER_PARSERS(uint);
DEFINE_INTEGER_PARSERS(long);
DEFINE_INTEGER_PARSERS(ulong);
DEFINE_INTEGER_PARSERS(longlong);
DEFINE_INTEGER_PARSERS(ulonglong);
#undef DEFINE_INTEGER_PARSERS
}