]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | /* |
2 | * | |
3 | * Copyright (c) 2004 | |
4 | * John Maddock | |
5 | * | |
6 | * Use, modification and distribution are subject to the | |
7 | * Boost Software License, Version 1.0. (See accompanying file | |
8 | * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) | |
9 | * | |
10 | */ | |
11 | ||
b32b8144 | 12 | #include <boost/regex.hpp> |
7c673cae FG |
13 | #include <iostream> |
14 | #include <fstream> | |
15 | #include <string> | |
16 | #include <vector> | |
7c673cae FG |
17 | |
18 | #ifdef BOOST_MSVC | |
19 | #pragma warning(disable:4512 4244) | |
20 | #endif | |
21 | ||
22 | #include <boost/program_options.hpp> | |
23 | ||
24 | namespace po = boost::program_options; | |
25 | ||
26 | int after_context; | |
27 | int before_context; | |
28 | bool print_byte_offset; | |
29 | bool count_only; | |
30 | std::string pattern; | |
31 | bool print_non_matching_files; | |
32 | bool files_only; | |
33 | bool print_line_numbers; | |
34 | ||
35 | boost::regex_constants::syntax_option_type flags = boost::regex_constants::basic; | |
36 | boost::regex re; | |
37 | boost::smatch what; | |
38 | std::string current_file; | |
39 | int file_count; | |
40 | ||
41 | void process_stream(std::istream& is) | |
42 | { | |
43 | std::string line; | |
44 | int match_found = 0; | |
45 | int linenum = 1; | |
46 | while(std::getline(is, line)) | |
47 | { | |
48 | bool result = boost::regex_search(line, what, re); | |
49 | if(result) | |
50 | { | |
51 | if(print_non_matching_files) | |
52 | return; | |
53 | if(files_only) | |
54 | { | |
55 | std::cout << current_file << std::endl; | |
56 | return; | |
57 | } | |
58 | if(!match_found && !count_only && (file_count > 1)) | |
59 | { | |
60 | std::cout << current_file << ":\n"; | |
61 | } | |
62 | ++match_found; | |
63 | if(!count_only) | |
64 | { | |
65 | if(print_line_numbers) | |
66 | { | |
67 | std::cout << linenum << ":"; | |
68 | } | |
69 | if(print_byte_offset) | |
70 | { | |
71 | std::cout << what.position() << ":"; | |
72 | } | |
73 | std::cout << what[0] << std::endl; | |
74 | } | |
75 | } | |
76 | ++linenum; | |
77 | } | |
78 | if(count_only && match_found) | |
79 | { | |
80 | std::cout << match_found << " matches found in file " << current_file << std::endl; | |
81 | } | |
82 | else if(print_non_matching_files && !match_found) | |
83 | { | |
84 | std::cout << current_file << std::endl; | |
85 | } | |
86 | } | |
87 | ||
88 | void process_file(const std::string& name) | |
89 | { | |
90 | current_file = name; | |
91 | std::ifstream is(name.c_str()); | |
92 | if(is.bad()) | |
93 | { | |
94 | std::cerr << "Unable to open file " << name << std::endl; | |
95 | } | |
96 | process_stream(is); | |
97 | } | |
98 | ||
99 | int main(int argc, char * argv[]) | |
100 | { | |
101 | try{ | |
102 | po::options_description opts("Options"); | |
103 | opts.add_options() | |
104 | ("help,h", "produce help message") | |
105 | //("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.") | |
106 | //("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.") | |
107 | //("context,C", po::value<int>(), "Print arg lines of output context. Places a line containing -- between contiguous groups of matches.") | |
108 | ("byte-offset,b", "Print the byte offset within the input file before each line of output.") | |
109 | ("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.") | |
110 | ("extended-regexp,E", "Interpret PATTERN as an POSIX-extended regular expression.") | |
111 | ("perl-regexp,P", "Interpret PATTERN as a Perl regular expression.") | |
112 | //("regexp,e", po::value<std::string>(&pattern), "Use PATTERN as the pattern; useful to protect patterns beginning with -.") | |
113 | ("basic-regexp,G", "Interpret arg as a POSIX-basic regular expression (see below). This is the default.") | |
114 | ("ignore-case,i", "Ignore case distinctions in both the PATTERN and the input files.") | |
115 | ("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.") | |
116 | ("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.") | |
117 | ("line-number,n", "Prefix each line of output with the line number within its input file.") | |
118 | ; | |
119 | // Hidden options, will be allowed both on command line and | |
120 | // in config file, but will not be shown to the user. | |
121 | po::options_description hidden("Hidden options"); | |
122 | hidden.add_options() | |
123 | ("input-file", po::value< std::vector<std::string> >(), "input file") | |
124 | ("input-pattern", po::value< std::string >(), "input file") | |
125 | ; | |
126 | ||
127 | po::options_description cmdline_options; | |
128 | cmdline_options.add(opts).add(hidden); | |
129 | ||
130 | po::positional_options_description p; | |
131 | p.add("input-pattern", 1); | |
132 | p.add("input-file", -1); | |
133 | ||
134 | po::variables_map vm; | |
135 | po::store(po::command_line_parser(argc, argv).options(cmdline_options)/*.options(hidden)*/.positional(p).run(), vm); | |
136 | po::notify(vm); | |
137 | ||
138 | if (vm.count("help")) | |
139 | { | |
140 | std::cout << opts << "\n"; | |
141 | return 0; | |
142 | } | |
143 | if (vm.count("context")) | |
144 | { | |
145 | after_context = vm["context"].as< int >(); | |
146 | before_context = after_context; | |
147 | } | |
148 | if(vm.count("extended-regexp")) | |
149 | { | |
150 | flags = boost::regex_constants::extended; | |
151 | } | |
152 | if(vm.count("basic-regexp")) | |
153 | { | |
154 | flags = boost::regex_constants::basic; | |
155 | } | |
156 | if(vm.count("perl-regexp")) | |
157 | { | |
158 | flags = boost::regex_constants::perl; | |
159 | } | |
160 | if(vm.count("ignore-case")) | |
161 | { | |
162 | flags |= boost::regex_constants::icase; | |
163 | } | |
164 | if(vm.count("byte-offset")) | |
165 | { | |
166 | print_byte_offset = true; | |
167 | } | |
168 | if(vm.count("count")) | |
169 | { | |
170 | count_only = true; | |
171 | } | |
172 | if(vm.count("files-without-match")) | |
173 | { | |
174 | print_non_matching_files = true; | |
175 | } | |
176 | if(vm.count("files-with-matches")) | |
177 | { | |
178 | files_only = true; | |
179 | } | |
180 | if(vm.count("line-number")) | |
181 | { | |
182 | print_line_numbers = true; | |
183 | } | |
184 | if(vm.count("input-pattern")) | |
185 | { | |
186 | pattern = vm["input-pattern"].as< std::string >(); | |
187 | re.assign(pattern, flags); | |
188 | } | |
189 | else | |
190 | { | |
191 | std::cerr << "No pattern specified" << std::endl; | |
192 | return 1; | |
193 | } | |
194 | if (vm.count("input-file")) | |
195 | { | |
196 | const std::vector<std::string>& files = vm["input-file"].as< std::vector<std::string> >(); | |
197 | file_count = files.size(); | |
198 | for(std::vector<std::string>::const_iterator i = files.begin(); i != files.end(); ++i) | |
199 | { | |
200 | process_file(*i); | |
201 | } | |
202 | } | |
203 | else | |
204 | { | |
205 | // no input files, scan stdin instead: | |
206 | process_stream(std::cin); | |
207 | } | |
208 | ||
209 | } | |
210 | catch(const std::exception& e) | |
211 | { | |
212 | std::cerr << e.what() << std::endl; | |
213 | } | |
214 | ||
215 | return 0; | |
216 | } | |
217 |