libs/regex/example/grep/grep.cpp
/* * * Copyright (c) 2004 * John Maddock * * Use, modification and distribution are subject to the * Boost Software License, Version 1.0. (See accompanying file * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) * */ #include <boost/regex.hpp> #include <iostream> #include <fstream> #include <string> #include <vector> #ifdef BOOST_MSVC #pragma warning(disable:4512 4244) #endif #include <boost/program_options.hpp> namespace po = boost::program_options; int after_context; int before_context; bool print_byte_offset; bool count_only; std::string pattern; bool print_non_matching_files; bool files_only; bool print_line_numbers; boost::regex_constants::syntax_option_type flags = boost::regex_constants::basic; boost::regex re; boost::smatch what; std::string current_file; int file_count; void process_stream(std::istream& is) { std::string line; int match_found = 0; int linenum = 1; while(std::getline(is, line)) { bool result = boost::regex_search(line, what, re); if(result) { if(print_non_matching_files) return; if(files_only) { std::cout << current_file << std::endl; return; } if(!match_found && !count_only && (file_count > 1)) { std::cout << current_file << ":\n"; } ++match_found; if(!count_only) { if(print_line_numbers) { std::cout << linenum << ":"; } if(print_byte_offset) { std::cout << what.position() << ":"; } std::cout << what[0] << std::endl; } } ++linenum; } if(count_only && match_found) { std::cout << match_found << " matches found in file " << current_file << std::endl; } else if(print_non_matching_files && !match_found) { std::cout << current_file << std::endl; } } void process_file(const std::string& name) { current_file = name; std::ifstream is(name.c_str()); if(is.bad()) { std::cerr << "Unable to open file " << name << std::endl; } process_stream(is); } 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; }