bool
Filesystem::get_directory_entries(const std::string& dirname,
std::vector<std::string>& filenames,
bool recursive,
const std::string& filter_regex)
{
filenames.clear();
if (dirname.size() && !is_directory(dirname))
return false;
filesystem::path dirpath(dirname.size() ? u8path(dirname)
: filesystem::path("."));
regex re;
try {
re = regex(filter_regex);
} catch (...) {
return false;
}
if (recursive) {
for (filesystem::recursive_directory_iterator s(dirpath);
s != filesystem::recursive_directory_iterator(); ++s) {
std::string file = pathstr(s->path());
if (!filter_regex.size() || regex_search(file, re))
filenames.push_back(file);
}
} else {
for (filesystem::directory_iterator s(dirpath);
s != filesystem::directory_iterator(); ++s) {
std::string file = pathstr(s->path());
if (!filter_regex.size() || regex_search(file, re))
filenames.push_back(file);
}
}
return true;
}
SvmParams::SvmParams(const std::string &filename) throw (IOException) {
static regex coefficients("betas: ([0-9 .\\-]+)");
static regex means("means: ([0-9 .\\-]+)");
static regex sigmas("sigmas: ([0-9 .\\-]+)");
static regex bias("bias: ([0-9.\\-]+)");
ifstream file(filename);
string current_line;
cmatch matches;
if (file.is_open()) {
do {
getline(file, current_line);
if (regex_search(current_line.c_str(), matches, coefficients)) {
this->coefficients = tokenize(matches[1]);
} else if (regex_search(current_line.c_str(), matches, means)) {
this->means = tokenize(matches[1]);
} else if (regex_search(current_line.c_str(), matches, sigmas)) {
this->sigmas = tokenize(matches[1]);
} else if (regex_search(current_line.c_str(), matches, bias)) {
this->bias = stod(matches[1]);
}
} while (current_line.length() > 0);
} else {
throw IOException("Couldn't open SVM parameters file.");
}
file.close();
}
CStrRegExprFindInstance(const regex * _regEx, const char * _str, size32_t _from, size32_t _len, bool _keep)
: regEx(_regEx)
{
matched = false;
sample = NULL;
try
{
if (_keep)
{
sample = (char *)rtlMalloc(_len + 1); //required for findstr
memcpy(sample, _str + _from, _len);
sample[_len] = (char)NULL;
matched = regex_search(sample, subs, *regEx);
}
else
{
matched = regex_search(_str + _from, _str + _len, subs, *regEx);
}
}
catch (const std::runtime_error & e)
{
std::string msg = "Error in regex search: ";
msg += e.what();
#if defined(_USE_BOOST_REGEX)
msg += "(regex: ";
msg += regEx->str();
msg += ")";
#endif
rtlFail(0, msg.c_str());
}
}
//==============================================================================
bool Uri::fromStringOrPath(const std::string& _input)
{
// TODO(JS): Need to check if _input is an "absolute" path?
#ifdef _WIN32
// Assume that any URI begin with pattern [SINGLE_LETTER]:[/ or \\] is an
// absolute path.
static regex windowsPathRegex(R"END([a-zA-Z]:[/|\\])END");
bool isPath = regex_search(_input, windowsPathRegex, match_continuous);
if (isPath)
return fromPath(_input);
#else
// Assume that any URI without a scheme is a path.
static regex uriSchemeRegex(R"END(^(([^:/?#]+):))END");
bool noScheme = !regex_search(_input, uriSchemeRegex, match_continuous);
if (noScheme)
return fromPath(_input);
#endif
return fromString(_input);
}
std::string MedicManager::handleMessage(Message* message, std::string regexPattern)
{
// Read the message out of the packet.
BString tmp;
message->getStringUnicode16(tmp);
// If the string has no length the message is ill-formatted, send the
// proper format to the client.
if (!tmp.getLength())
return "";
// Convert the string to an ansi string for ease with the regex.
tmp.convert(BSTRType_ANSI);
std::string input_string(tmp.getAnsi());
static const regex pattern(regexPattern);
smatch result;
regex_search(input_string, result, pattern);
// Gather the results of the pattern for validation and use.
std::string messageType(result[1]);
if (messageType.length() > 0)
{
return messageType;
}
return "";
}
bool CForbiddenPro::parse_condition_regex(const string& query, const vector<string>& condition_regex)const {
for (size_t i = 0; i < condition_regex.size(); i++) {
boost::regex regex(condition_regex[i].c_str());
if (regex_search(query, regex)) {
return true;
}
}
return false;
}
void CrowdinClient::HandleOAuthCallback(const std::string& uri)
{
if (!m_authCallback)
return;
const regex re("access_token=([^&]+)&");
smatch m;
if (!regex_search(uri, m, re))
return;
SaveAndSetToken(m.str(1));
m_authCallback();
m_authCallback = nullptr;
}
// Reads from fin and returns a std::set with all the found authors, using the
// collection of patterns to find the authors in the stream.
template<typename T> set<string, custom_string_cmp>
get_authors(FILE* fin, const T& collection) {
set<string, custom_string_cmp> authors;
char buffer[BUFSIZ];
while (fgets(buffer, sizeof(buffer), fin)) {
for (const auto& regex_ : collection) {
cmatch match;
if (regex_search(buffer, match, regex_)) {
string author_name = match.str(1);
authors.emplace(*strip_in_place(&author_name, " \n\r\t."));
break; // Go to next line on first match
}
}
}
return authors;
}
bool CForbiddenPro::parse_condition_regex(const string& query,
const vector<string>& condition_regex, string& forbidden_word)const {
std::string tmp_query = query;
// toUpper
std::transform(tmp_query.begin(), tmp_query.end(), tmp_query.begin(), ::toupper);
for (size_t i = 0; i < condition_regex.size(); i++) {
boost::regex regex(condition_regex[i].c_str());
if (regex_search(tmp_query, regex)) {
forbidden_word = condition_regex[i];
return true;
}
}
return false;
}
int main(int argc, char** argv)
{
Configuration configuration = Configuration(argc, argv);
vector<string>* lines = getLines(*configuration.filename);
// run test
string patternString;
if(configuration.withOrOperator)
{
patternString = "\\d+|\\w+\\d+\\.";
}
else
{
patternString = "\\d+";
}
regex pattern(patternString);
int countMatches = 0;
if(configuration.dryRun)
{
for(vector<string>::const_iterator iterator = lines->begin(); iterator != lines->end(); iterator++);
}
else
{
for(vector<string>::const_iterator iterator = lines->begin(); iterator != lines->end(); iterator++)
{
if(regex_search(*iterator, pattern))
{
countMatches++;
}
}
}
//cout << countMatches << endl;
delete lines;
//cout << "done" << endl;
return 0;
}
void printMatches(const string & textToSearch, const string & regularExpression) {
using std::endl;
using std::cout;
using boost::regex;
using boost::regex_search;
using boost::smatch;
cout << endl << "Looking for " << regularExpression << " in " << textToSearch << endl;
string::const_iterator start = textToSearch.begin();
string::const_iterator end = textToSearch.end();
regex expression(regularExpression);
smatch result;
cout << "\tMatched: ";
while(regex_search(start,end,result,expression)) {
cout << result << " ";
start = result[0].second;
}
cout << endl;
}
/**
Is Paraview at this location.
@return TRUE if determined to be present.
*/
bool isParaviewHere(const QString& location)
{
using boost::regex;
using boost::regex_search;
bool found = false;
if(!location.isEmpty())
{
QDirIterator it(location, QDirIterator::NoIteratorFlags);
while (it.hasNext())
{
it.next();
QString file =it.fileName();
regex expression("^(paraview.exe)", boost::regex::icase);
if(regex_search(file.toStdString(), expression) && it.fileInfo().isFile())
{
found = true;
break;
}
}
}
return found;
}
GncNumeric::GncNumeric(const std::string& str, bool autoround)
{
static const std::string numer_frag("(-?[0-9]+)");
static const std::string denom_frag("([0-9]+)");
static const std::string hex_frag("(0x[a-f0-9]+)");
static const std::string slash( "[ \\t]*/[ \\t]*");
/* The llvm standard C++ library refused to recognize the - in the
* numer_frag patter with the default ECMAScript syntax so we use the awk
* syntax.
*/
static const regex numeral(numer_frag);
static const regex hex(hex_frag);
static const regex numeral_rational(numer_frag + slash + denom_frag);
static const regex hex_rational(hex_frag + slash + hex_frag);
static const regex hex_over_num(hex_frag + slash + denom_frag);
static const regex num_over_hex(numer_frag + slash + hex_frag);
static const regex decimal(numer_frag + "[.,]" + denom_frag);
smatch m;
/* The order of testing the regexes is from the more restrictve to the less
* restrictive, as less-restrictive ones will match patterns that would also
* match the more-restrictive and so invoke the wrong construction.
*/
if (str.empty())
throw std::invalid_argument("Can't construct a GncNumeric from an empty string.");
if (regex_search(str, m, hex_rational))
{
GncNumeric n(stoll(m[1].str(), nullptr, 16),
stoll(m[2].str(), nullptr, 16));
m_num = n.num();
m_den = n.denom();
return;
}
if (regex_search(str, m, hex_over_num))
{
GncNumeric n(stoll(m[1].str(), nullptr, 16),
stoll(m[2].str()));
m_num = n.num();
m_den = n.denom();
return;
}
if (regex_search(str, m, num_over_hex))
{
GncNumeric n(stoll(m[1].str()),
stoll(m[2].str(), nullptr, 16));
m_num = n.num();
m_den = n.denom();
return;
}
if (regex_search(str, m, numeral_rational))
{
GncNumeric n(stoll(m[1].str()), stoll(m[2].str()));
m_num = n.num();
m_den = n.denom();
return;
}
if (regex_search(str, m, decimal))
{
GncInt128 high(stoll(m[1].str()));
GncInt128 low(stoll(m[2].str()));
int64_t d = powten(m[2].str().length());
GncInt128 n = high * d + (high > 0 ? low : -low);
if (!autoround && n.isBig())
{
std::ostringstream errmsg;
errmsg << "Decimal string " << m[1].str() << "." << m[2].str()
<< "can't be represented in a GncNumeric without rounding.";
throw std::overflow_error(errmsg.str());
}
while (n.isBig() && d > 0)
{
n >>= 1;
d >>= 1;
}
if (n.isBig()) //Shouldn't happen, of course
{
std::ostringstream errmsg;
errmsg << "Decimal string " << m[1].str() << "." << m[2].str()
<< " can't be represented in a GncNumeric, even after reducing denom to " << d;
throw std::overflow_error(errmsg.str());
}
GncNumeric gncn(static_cast<int64_t>(n), d);
m_num = gncn.num();
m_den = gncn.denom();
return;
}
if (regex_search(str, m, hex))
{
GncNumeric n(stoll(m[1].str(), nullptr, 16),INT64_C(1));
m_num = n.num();
m_den = n.denom();
return;
}
if (regex_search(str, m, numeral))
{
GncNumeric n(stoll(m[1].str()), INT64_C(1));
m_num = n.num();
m_den = n.denom();
return;
}
std::ostringstream errmsg;
errmsg << "String " << str << " contains no recognizable numeric value.";
throw std::invalid_argument(errmsg.str());
}
bool
Filesystem::parse_pattern(const char* pattern_, int framepadding_override,
std::string& normalized_pattern,
std::string& framespec)
{
std::string pattern(pattern_);
// The pattern is either a range (e.g., "1-15#"), a
// set of hash marks (e.g. "####"), or a printf-style format
// string (e.g. "%04d").
#define ONERANGE_SPEC "[0-9]+(-[0-9]+((x|y)-?[0-9]+)?)?"
#define MANYRANGE_SPEC ONERANGE_SPEC "(," ONERANGE_SPEC ")*"
#define SEQUENCE_SPEC \
"(" MANYRANGE_SPEC ")?" \
"((#|@)+|(%[0-9]*d))"
static regex sequence_re(SEQUENCE_SPEC);
// std::cout << "pattern >" << (SEQUENCE_SPEC) << "<\n";
match_results<std::string::const_iterator> range_match;
if (!regex_search(pattern, range_match, sequence_re)) {
// Not a range
static regex all_views_re("%[Vv]");
if (regex_search(pattern, all_views_re)) {
normalized_pattern = pattern;
return true;
}
return false;
}
// It's a range. Generate the names by iterating through the numbers.
std::string thematch(range_match[0].first, range_match[0].second);
std::string thesequence(range_match[1].first, range_match[1].second);
std::string thehashes(range_match[9].first, range_match[9].second);
std::string theformat(range_match[11].first, range_match[11].second);
std::string prefix(range_match.prefix().first, range_match.prefix().second);
std::string suffix(range_match.suffix().first, range_match.suffix().second);
// std::cout << "theformat: " << theformat << "\n";
std::string fmt;
if (theformat.length() > 0) {
fmt = theformat;
} else {
// Compute the amount of padding desired
int padding = 0;
for (int i = (int)thematch.length() - 1; i >= 0; --i) {
if (thematch[i] == '#')
padding += 4;
else if (thematch[i] == '@')
padding += 1;
}
if (framepadding_override > 0)
padding = framepadding_override;
fmt = Strutil::sprintf("%%0%dd", padding);
}
// std::cout << "Format: '" << fmt << "'\n";
normalized_pattern = prefix + fmt + suffix;
framespec = thesequence;
return true;
}
////////////////////////////////////////////////////////////////////////////////
// 'isAbbreviation' returns true if the string ends on an
// abbreviation, false otherwise.
////////////////////////////////////////////////////////////////////////////////
bool
isAbbreviation(const StringXML& line) {
const StringXML abbreviations=
"(\\d+[-\\.:]+(\\d+[-\\.:]+)+$)|"
"(\\.\\.+$)|"
"(_\\s*$)|"
"(\\w+\\.+(\\w+\\.+)+$)|"
"(A\\.$)|"
"(Adm\\.$)|"
"(Ark\\.$)|"
"(Apr\\.$)|"
"(Aug\\.$)|"
"(B\\.$)|"
"(C\\.$)|"
"(Calif\\.$)|"
"(Capt\\.$)|"
"(Cmdr\\.$)|"
"(Co\\.$)|"
"(Conn\\.$)|"
"(Cpl\\.$)|"
"(D\\.$)|"
"(Dec\\.$)|"
"(Dr\\.$)|"
"(E\\.$)|"
"(F\\.$)|"
"(F\\.W\\.$)|"
"(Feb\\.$)|"
"(Fla\\.$)|"
"(G\\.$)|"
"(Ga\\.$)|"
"(Gen\\.$)|"
"(Gov\\.$)|"
"(H\\.$)|"
"(I\\.$)|"
"(Iraq-U\\.N\\.$)|"
"(Inc\\.$)|"
"(J\\.$)|"
"(Jan\\.$)|"
"(Jun\\.$)|"
"(Jul\\.$)|"
"(Jr\\.$)|"
"(K\\.$)|"
"(Ky\\.$)|"
"(L\\.$)|"
"(La\\.$)|"
"(Lt\\.$)|"
"(Ltd\\.$)|"
"(m\\.$)|"
"(M\\.$)|"
"(Maj\\.$)|"
"(Mar\\.$)|"
"(May\\.$)|"
"(Md\\.$)|"
"(Mo\\.$)|"
"(Mr\\.$)|"
"(Ms\\.$)|"
"(Mt\\.$)|"
"(N\\.$)|"
"(Neb\\.$)|"
"(Nev\\.$)|"
"(No\\.$)|"
"(\\(No\\.$)|"
"(Nov\\.$)|"
"(O\\.$)|"
"(Oct\\.$)|"
"(Ore\\.$)|"
"(P\\.$)|"
"(Pa\\.$)|"
"(Q\\.$)|"
"(R\\.$)|"
"(Rep\\.$)|"
"(Rev\\.$)|"
"(R.I\\.$)|"
"(S\\.$)|"
"(SA\\.$)|"
"(Sen\\.$)|"
"(Sep\\.$)|"
"(Sgt\\.$)|"
"(St\\.$)|"
"(ST\\.$)|"
"(T\\.$)|"
"(Tenn\\.$)|"
"(U\\.$)|"
"(V\\.$)|"
"(Va\\.$)|"
"(vs\\.$)|"
"(W\\.$)|"
"(X\\.$)|"
"(Y\\.$)|"
"(Z\\.$)";
static const regex abbrRegex(abbreviations);
return regex_search(line, abbrRegex);
}
bool
Filesystem::scan_for_matching_filenames(const std::string& pattern,
const std::vector<string_view>& views,
std::vector<int>& frame_numbers,
std::vector<string_view>& frame_views,
std::vector<std::string>& filenames)
{
static regex format_re("%0([0-9]+)d");
static regex all_views_re("%[Vv]"), view_re("%V"), short_view_re("%v");
frame_numbers.clear();
frame_views.clear();
filenames.clear();
if (regex_search(pattern, all_views_re)) {
if (regex_search(pattern, format_re)) {
// case 1: pattern has format and view
std::vector<std::pair<std::pair<int, string_view>, std::string>>
matches;
for (const auto& view : views) {
if (view.empty())
continue;
const string_view short_view = view.substr(0, 1);
std::vector<int> view_numbers;
std::vector<std::string> view_filenames;
std::string view_pattern = pattern;
view_pattern = Strutil::replace(view_pattern, "%V", view, true);
view_pattern = Strutil::replace(view_pattern, "%v", short_view,
true);
if (!scan_for_matching_filenames(view_pattern, view_numbers,
view_filenames))
continue;
for (int j = 0, f = view_numbers.size(); j < f; ++j) {
matches.push_back(
std::make_pair(std::make_pair(view_numbers[j], view),
view_filenames[j]));
}
}
std::sort(matches.begin(), matches.end());
for (auto& m : matches) {
frame_numbers.push_back(m.first.first);
frame_views.push_back(m.first.second);
filenames.push_back(m.second);
}
} else {
// case 2: pattern has view, but no format
std::vector<std::pair<string_view, std::string>> matches;
for (const auto& view : views) {
const string_view short_view = view.substr(0, 1);
std::string view_pattern = pattern;
view_pattern = Strutil::replace(view_pattern, "%V", view, true);
view_pattern = Strutil::replace(view_pattern, "%v", short_view,
true);
if (exists(view_pattern))
matches.push_back(std::make_pair(view, view_pattern));
}
std::sort(matches.begin(), matches.end());
for (auto& m : matches) {
frame_views.push_back(m.first);
filenames.push_back(m.second);
}
}
return true;
} else {
// case 3: pattern has format, but no view
return scan_for_matching_filenames(pattern, frame_numbers, filenames);
}
return true;
}
bool
Filesystem::scan_for_matching_filenames(const std::string& pattern_,
std::vector<int>& numbers,
std::vector<std::string>& filenames)
{
numbers.clear();
filenames.clear();
std::string pattern = pattern_;
// Isolate the directory name (or '.' if none was specified)
std::string directory = Filesystem::parent_path(pattern);
if (directory.size() == 0) {
directory = ".";
#ifdef _WIN32
pattern = ".\\\\" + pattern;
#else
pattern = "./" + pattern;
#endif
}
if (!exists(directory))
return false;
// build a regex that matches the pattern
static regex format_re("%0([0-9]+)d");
match_results<std::string::const_iterator> format_match;
if (!regex_search(pattern, format_match, format_re))
return false;
std::string thepadding(format_match[1].first, format_match[1].second);
std::string prefix(format_match.prefix().first,
format_match.prefix().second);
std::string suffix(format_match.suffix().first,
format_match.suffix().second);
std::string pattern_re_str = prefix + "([0-9]{" + thepadding + ",})"
+ suffix;
std::vector<std::pair<int, std::string>> matches;
// There are some corner cases regex that could be constructed here that
// are badly structured and might throw an exception.
try {
regex pattern_re(pattern_re_str);
filesystem::directory_iterator end_it;
for (filesystem::directory_iterator it(u8path(directory)); it != end_it;
++it) {
const std::string f = pathstr(it->path());
if (is_regular(f)) {
match_results<std::string::const_iterator> frame_match;
if (regex_match(f, frame_match, pattern_re)) {
std::string thenumber(frame_match[1].first,
frame_match[1].second);
int frame = Strutil::stoi(thenumber);
matches.push_back(std::make_pair(frame, f));
}
}
}
} catch (...) {
// Botched regex. Just fail.
return false;
}
// filesystem order is undefined, so return sorted sequences
std::sort(matches.begin(), matches.end());
for (auto& m : matches) {
numbers.push_back(m.first);
filenames.push_back(m.second);
}
return true;
}
static bool
grep_file(const std::string& filename, regex& re,
bool ignore_nonimage_files = false)
{
if (!Filesystem::exists(filename)) {
std::cerr << "igrep: " << filename << ": No such file or directory\n";
return false;
}
if (Filesystem::is_directory(filename)) {
if (!recursive)
return false;
if (print_dirs) {
std::cout << "(" << filename << "/)\n";
std::cout.flush();
}
bool r = false;
std::vector<std::string> directory_entries;
Filesystem::get_directory_entries(filename, directory_entries);
for (const auto& d : directory_entries)
r |= grep_file(d, re, true);
return r;
}
auto in = ImageInput::open(filename);
if (!in.get()) {
if (!ignore_nonimage_files)
std::cerr << geterror() << "\n";
return false;
}
ImageSpec spec = in->spec();
if (file_match) {
bool match = regex_search(filename, re);
if (match && !invert_match) {
std::cout << filename << "\n";
return true;
}
}
bool found = false;
int subimage = 0;
do {
if (!all_subimages && subimage > 0)
break;
for (auto&& p : spec.extra_attribs) {
TypeDesc t = p.type();
if (t.elementtype() == TypeDesc::STRING) {
int n = t.numelements();
for (int i = 0; i < n; ++i) {
bool match = regex_search(((const char**)p.data())[i], re);
found |= match;
if (match && !invert_match) {
if (list_files) {
std::cout << filename << "\n";
return found;
}
std::cout << filename << ": " << p.name() << " = "
<< ((const char**)p.data())[i] << "\n";
}
}
}
}
} while (in->seek_subimage(++subimage, 0, spec));
if (invert_match) {
found = !found;
if (found)
std::cout << filename << "\n";
}
return found;
}
