int main(int argc, const char** argv) { try{ e1.assign(expression_text); e2.assign(pre_expression); for(int i = 1; i < argc; ++i) { std::cout << "Processing file " << argv[i] << std::endl; std::ifstream fs(argv[i]); std::string in; load_file(in, fs); fs.close(); std::string out_name = std::string(argv[i]) + std::string(".htm"); std::ofstream os(out_name.c_str()); os << header_text; // strip '<' and '>' first by outputting to a // temporary string stream std::ostringstream t(std::ios::out | std::ios::binary); std::ostream_iterator<char> oi(t); boost::regex_replace(oi, in.begin(), in.end(), e2, pre_format, boost::match_default | boost::format_all); // then output to final output stream // adding syntax highlighting: std::string s(t.str()); std::ostream_iterator<char> out(os); boost::regex_replace(out, s.begin(), s.end(), e1, format_string, boost::match_default | boost::format_all); os << footer_text; os.close(); } } catch(...) { return -1; } return 0; }
bool operator()(boost::regex& r) const { try { if (wildCard) { r.assign(AirUtil::regexEscape(pattern, true), boost::regex::icase); } else { r.assign(pattern); } return true; } catch(const std::runtime_error&) { LogManager::getInstance()->message(STRING_F(INVALID_PATTERN, pattern), LogManager::LOG_ERROR); return false; } }
bool EnumService::parse_regex_replace(const std::string& regex_replace, boost::regex& regex, std::string& replace) { bool success = false; // Split the regular expression into the match and replace sections. RFC3402 // says any character other than 1-9 or i can be the delimiter, but // recommends / or !. We just use the first character and reject if it // doesn't neatly split the regex into two. std::vector<std::string> match_replace; Utils::split_string(regex_replace, regex_replace[0], match_replace); if (match_replace.size() == 2) { TRC_DEBUG("Split regex into match=%s, replace=%s", match_replace[0].c_str(), match_replace[1].c_str()); try { regex.assign(match_replace[0], boost::regex::extended); replace = match_replace[1]; success = true; } catch (...) { success = false; } } else { success = false; } return success; }
void Location::parseGprmc(string gprmc) { DebugOut(7)<<"parsing gprmc message"<<endl; regularExpression.assign(gprmcRegEx); boost::smatch tokens; if (boost::regex_match (gprmc, tokens, regularExpression) ) { if(tokens[4] == "A") { isActive = true; } int i=0; for(auto tok : tokens) { DebugOut(0)<<i++<<":"<<tok<<endl; } parseTime(tokens[1],tokens[2],tokens[3],tokens[13],tokens[14],tokens[15]); parseLatitude(tokens[5], tokens[6], tokens[7]); parseLongitude(tokens[8], tokens[9], tokens[10]); parseSpeed(tokens[11]); parseDirection(tokens[12]); } }
void bcp_implementation::copy_path(const fs::path& p) { assert(!fs::is_directory(m_boost_path / p)); if(fs::exists(m_dest_path / p)) { std::cout << "Copying (and overwriting) file: " << p.string() << "\n"; fs::remove(m_dest_path / p); } else std::cout << "Copying file: " << p.string() << "\n"; // // create the path to the new file if it doesn't already exist: // create_path(p.branch_path()); // // do text based copy if requested: // if(p.leaf() == "Jamroot") { static std::vector<char> v1, v2; v1.clear(); v2.clear(); std::ifstream is((m_boost_path / p).c_str()); std::copy(std::istreambuf_iterator<char>(is), std::istreambuf_iterator<char>(), std::back_inserter(v1)); static boost::regex libname_matcher; if(libname_matcher.empty()) { libname_matcher.assign("boost_"); } regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), libname_matcher, m_namespace_name + "_"); std::swap(v1, v2); v2.clear(); std::ofstream os; if(m_unix_lines) os.open((m_dest_path / p).c_str(), std::ios_base::binary | std::ios_base::out); else os.open((m_dest_path / p).c_str(), std::ios_base::out); os.write(&*v1.begin(), v1.size()); os.close(); } else if(m_namespace_name.size() && m_lib_names.size() && is_jam_file(p)) { static std::vector<char> v1, v2; v1.clear(); v2.clear(); std::ifstream is((m_boost_path / p).c_str()); std::copy(std::istreambuf_iterator<char>(is), std::istreambuf_iterator<char>(), std::back_inserter(v1)); static boost::regex libname_matcher; if(libname_matcher.empty()) { std::string re = "\\<"; re += *m_lib_names.begin(); for(std::set<std::string>::const_iterator i = ++m_lib_names.begin(); i != m_lib_names.end(); ++i) { re += "|" + *i; } re += "\\>"; libname_matcher.assign(re); } regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), libname_matcher, get_new_library_name(m_namespace_name)); std::swap(v1, v2); v2.clear(); std::ofstream os; if(m_unix_lines) os.open((m_dest_path / p).c_str(), std::ios_base::binary | std::ios_base::out); else os.open((m_dest_path / p).c_str(), std::ios_base::out); os.write(&*v1.begin(), v1.size()); os.close(); } else if(m_namespace_name.size() && is_source_file(p)) { // // v1 hold the current content, v2 is temp buffer. // Each time we do a search and replace the new content // ends up in v2: we then swap v1 and v2, and clear v2. // static std::vector<char> v1, v2; v1.clear(); v2.clear(); std::ifstream is((m_boost_path / p).c_str()); std::copy(std::istreambuf_iterator<char>(is), std::istreambuf_iterator<char>(), std::back_inserter(v1)); static const boost::regex namespace_matcher( "(?|" "(namespace\\s+)boost(_\\w+)?(?:(\\s*::\\s*)phoenix)?" "|" "(namespace\\s+)(adstl|phoenix|rapidxml)\\>" "|" "()\\<boost((?:_(?!intrusive_tags)\\w+)?\\s*(?:::))(?:(\\s*)phoenix)?" "|" "()\\<((?:adstl|phoenix|rapidxml)\\s*(?:::))" "|" "(namespace\\s+\\w+\\s*=\\s*(?:::\\s*)?)boost(_\\w+)?(?:(\\s*::\\s*)phoenix)?" "|" "(namespace\\s+\\w+\\s*=\\s*(?:::\\s*)?(?:\\w+\\s*::\\s*)?)(adstl|phoenix|rapidxml)\\>" "|" "(^\\s*#\\s*define\\s+\\w+\\s+)boost((?:_\\w+)?\\s*)$" "|" "(^\\s*#\\s*define[^\\n]+)((?:adstl|phoenix|rapidxml)\\s*)$" "|" "()boost(_asio_detail_posix_thread_function|_regex_free_static_mutex)" "|" "()(lw_thread_routine|at_thread_exit|on_process_enter|on_process_exit|on_thread_enter|on_thread_exit|tss_cleanup_implemented)" "|" "(BOOST_CLASS_REQUIRE4?[^;]*)boost((?:_\\w+)?\\s*,)" "|" "(\\(\\s*)boost(\\s*\\))" ")" ); regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), namespace_matcher, "$1" + m_namespace_name + "$2(?3$3" + m_namespace_name + "phoenix)", boost::regex_constants::format_all); std::swap(v1, v2); v2.clear(); if(m_namespace_alias) { static const boost::regex namespace_alias( /* "namespace\\s+" + m_namespace_name + "\\s*" "(" "\\{" "(?:" "(?>[^\\{\\}/]+)" "(?>" "(?:" "(?1)" "|//[^\\n]+$" "|/[^/]" "|(?:^\\s*#[^\\n]*" "(?:(?<=\\\\)\\n[^\\n]*)*)" ")" "[^\\{\\}]+" ")*" ")*" "\\}" ")" */ /* "(namespace\\s+" + m_namespace_name + "\\s*\\{.*" "\\})([^\\{\\};]*)\\z" */ "namespace\\s+" + m_namespace_name + "\\s*\\{" ); regex_replace(std::back_inserter(v2), v1.begin(), v1.end(), namespace_alias, "namespace " + m_namespace_name + "{} namespace boost = " + m_namespace_name + "; namespace " + m_namespace_name + "{"); std::swap(v1, v2); v2.clear(); } std::ofstream os; if(m_unix_lines) os.open((m_dest_path / p).c_str(), std::ios_base::binary | std::ios_base::out); else os.open((m_dest_path / p).c_str(), std::ios_base::out); if(v1.size()) os.write(&*v1.begin(), v1.size()); os.close(); } else if(m_unix_lines && !is_binary_file(p)) { std::ifstream is((m_boost_path / p).c_str()); std::istreambuf_iterator<char> isi(is); std::istreambuf_iterator<char> end; std::ofstream os((m_dest_path / p).c_str(), std::ios_base::binary | std::ios_base::out); std::ostreambuf_iterator<char> osi(os); std::copy(isi, end, osi); } else { // binary copy: fs::copy_file(m_boost_path / p, m_dest_path / p); } }
MarkExtracter(std::ostream& inOutStream, const DesignSharedPtr& inDesign, string inPattern) : mStream(inOutStream), mDesign(inDesign), mPattern(inPattern) { mStream << "Searching for '" << mPattern << "'" << std::endl; mStream << "NEAT" << std::endl; mRegex.assign(mPattern); }
int main(int argc, char * argv[]) { try{ po::options_description opts("Options"); opts.add_options() ("help,h", "produce help message") //("after-context,A", po::value<int>(&after_context)->default_value(0), "Print arg lines of trailing context after matching lines. Places a line containing -- between contiguous groups of matches.") //("before-context,B", po::value<int>(&before_context)->default_value(0), "Print arg lines of leading context before matching lines. Places a line containing -- between contiguous groups of matches.") //("context,C", po::value<int>(), "Print arg lines of output context. Places a line containing -- between contiguous groups of matches.") ("byte-offset,b", "Print the byte offset within the input file before each line of output.") ("count,c", "Suppress normal output; instead print a count of matching lines for each input file. With the -v, --invert-match option (see below), count non-matching lines.") ("extended-regexp,E", "Interpret PATTERN as an POSIX-extended regular expression.") ("perl-regexp,P", "Interpret PATTERN as a Perl regular expression.") //("regexp,e", po::value<std::string>(&pattern), "Use PATTERN as the pattern; useful to protect patterns beginning with -.") ("basic-regexp,G", "Interpret arg as a POSIX-basic regular expression (see below). This is the default.") ("ignore-case,i", "Ignore case distinctions in both the PATTERN and the input files.") ("files-without-match,L", "Suppress normal output; instead print the name of each input file from which no output would normally have been printed. The scanning will stop on the first match.") ("files-with-matches,l", "Suppress normal output; instead print the name of each input file from which output would normally have been printed. The scanning will stop on the first match.") ("line-number,n", "Prefix each line of output with the line number within its input file.") ; // Hidden options, will be allowed both on command line and // in config file, but will not be shown to the user. po::options_description hidden("Hidden options"); hidden.add_options() ("input-file", po::value< std::vector<std::string> >(), "input file") ("input-pattern", po::value< std::string >(), "input file") ; po::options_description cmdline_options; cmdline_options.add(opts).add(hidden); po::positional_options_description p; p.add("input-pattern", 1); p.add("input-file", -1); po::variables_map vm; po::store(po::command_line_parser(argc, argv).options(cmdline_options)/*.options(hidden)*/.positional(p).run(), vm); po::notify(vm); if (vm.count("help")) { std::cout << opts << "\n"; return 0; } if (vm.count("context")) { after_context = vm["context"].as< int >(); before_context = after_context; } if(vm.count("extended-regexp")) { flags = boost::regex_constants::extended; } if(vm.count("basic-regexp")) { flags = boost::regex_constants::basic; } if(vm.count("perl-regexp")) { flags = boost::regex_constants::perl; } if(vm.count("ignore-case")) { flags |= boost::regex_constants::icase; } if(vm.count("byte-offset")) { print_byte_offset = true; } if(vm.count("count")) { count_only = true; } if(vm.count("files-without-match")) { print_non_matching_files = true; } if(vm.count("files-with-matches")) { files_only = true; } if(vm.count("line-number")) { print_line_numbers = true; } if(vm.count("input-pattern")) { pattern = vm["input-pattern"].as< std::string >(); re.assign(pattern, flags); } else { std::cerr << "No pattern specified" << std::endl; return 1; } if (vm.count("input-file")) { const std::vector<std::string>& files = vm["input-file"].as< std::vector<std::string> >(); file_count = files.size(); for(std::vector<std::string>::const_iterator i = files.begin(); i != files.end(); ++i) { process_file(*i); } } else { // no input files, scan stdin instead: process_stream(std::cin); } } catch(const std::exception& e) { std::cerr << e.what() << std::endl; } return 0; }
int main (int argc, const char *argv[]) { Filesystem::convert_native_arguments (argc, (const char **)argv); ArgParse ap; ap.options ("iinfo -- print information about images\n" OIIO_INTRO_STRING "\n" "Usage: iinfo [options] filename...", "%*", parse_files, "", "--help", &help, "Print help message", "-v", &verbose, "Verbose output", "-m %s", &metamatch, "Metadata names to print (default: all)", "-f", &filenameprefix, "Prefix each line with the filename", "-s", &sum, "Sum the image sizes", "-a", &subimages, "Print info about all subimages", "--hash", &compute_sha1, "Print SHA-1 hash of pixel values", "--stats", &compute_stats, "Print image pixel statistics (data window)", NULL); if (ap.parse(argc, argv) < 0 || filenames.empty()) { std::cerr << ap.geterror() << std::endl; ap.usage (); return EXIT_FAILURE; } if (help) { ap.usage (); exit (EXIT_FAILURE); } if (! metamatch.empty()) field_re.assign (metamatch, boost::regex::extended | boost::regex_constants::icase); // Find the longest filename size_t longestname = 0; BOOST_FOREACH (const std::string &s, filenames) longestname = std::max (longestname, s.length()); longestname = std::min (longestname, (size_t)40); long long totalsize = 0; BOOST_FOREACH (const std::string &s, filenames) { ImageInput *in = ImageInput::open (s.c_str()); if (! in) { std::string err = geterror(); if (err.empty()) err = Strutil::format ("Could not open \"%s\"", s.c_str()); std::cerr << "iinfo: " << err << "\n"; continue; } ImageSpec spec = in->spec(); print_info (s, longestname, in, spec, verbose, sum, totalsize); in->close (); delete in; }