Commit | Line | Data |
---|---|---|
b75a7d8f A |
1 | /************************************************************************** |
2 | * | |
729e4ab9 | 3 | * Copyright (C) 2002-2010, International Business Machines |
b75a7d8f A |
4 | * Corporation and others. All Rights Reserved. |
5 | * | |
6 | *************************************************************************** | |
7 | */ | |
8 | ||
9 | // | |
10 | // ugrep - an ICU sample program illustrating the use of ICU Regular Expressions. | |
11 | // | |
12 | // The use of the ICU Regex API all occurs within the main() | |
13 | // function. The rest of the code deals with with opening files, | |
14 | // encoding conversions, printing results, etc. | |
15 | // | |
16 | // This is not a full-featured grep program. The command line options | |
17 | // have been kept to a minimum to avoid complicating the sample code. | |
18 | // | |
19 | ||
20 | ||
21 | ||
22 | #include <stdio.h> | |
23 | #include <stdlib.h> | |
24 | #include <string.h> | |
25 | ||
26 | #include "unicode/utypes.h" | |
27 | #include "unicode/ustring.h" | |
28 | #include "unicode/regex.h" | |
29 | #include "unicode/ucnv.h" | |
30 | #include "unicode/uclean.h" | |
31 | ||
32 | ||
33 | // | |
34 | // The following variables contain paramters that may be set from the command line. | |
35 | // | |
36 | const char *pattern = NULL; // The regular expression | |
37 | int firstFileNum; // argv index of the first file name | |
38 | UBool displayFileName = FALSE; | |
39 | UBool displayLineNum = FALSE; | |
40 | ||
41 | ||
42 | // | |
43 | // Info regarding the file currently being processed | |
44 | // | |
45 | const char *fileName; | |
46 | int fileLen; // Length, in UTF-16 Code Units. | |
47 | ||
48 | UChar *ucharBuf = 0; // Buffer, holds converted file. (Simple minded program, always reads | |
49 | // the whole file at once. | |
50 | ||
51 | char *charBuf = 0; // Buffer, for original, unconverted file data. | |
52 | ||
53 | ||
54 | // | |
55 | // Info regarding the line currently being processed | |
56 | // | |
57 | int lineStart; // Index of first char of the current line in the file buffer | |
58 | int lineEnd; // Index of char following the new line sequence for the current line | |
59 | int lineNum; | |
60 | ||
61 | // | |
62 | // Converter, used on output to convert Unicode data back to char * | |
63 | // so that it will display in non-Unicode terminal windows. | |
64 | // | |
65 | UConverter *outConverter = 0; | |
66 | ||
67 | // | |
68 | // Function forward declarations | |
69 | // | |
70 | void processOptions(int argc, const char **argv); | |
71 | void nextLine(int start); | |
72 | void printMatch(); | |
73 | void printUsage(); | |
74 | void readFile(const char *name); | |
75 | ||
76 | ||
77 | ||
78 | //------------------------------------------------------------------------------------------ | |
79 | // | |
80 | // main for ugrep | |
81 | // | |
82 | // Structurally, all use of the ICU Regular Expression API is in main(), | |
83 | // and all of the supporting stuff necessary to make a running program, but | |
84 | // not directly related to regular expressions, is factored out into these other | |
85 | // functions. | |
86 | // | |
87 | //------------------------------------------------------------------------------------------ | |
88 | int main(int argc, const char** argv) { | |
89 | UBool matchFound = FALSE; | |
90 | ||
91 | // | |
92 | // Process the commmand line options. | |
93 | // | |
94 | processOptions(argc, argv); | |
95 | ||
96 | // | |
97 | // Create a RegexPattern object from the user supplied pattern string. | |
98 | // | |
99 | UErrorCode status = U_ZERO_ERROR; // All ICU operations report success or failure | |
100 | // in a status variable. | |
101 | ||
102 | UParseError parseErr; // In the event of a syntax error in the regex pattern, | |
103 | // this struct will contain the position of the | |
104 | // error. | |
105 | ||
106 | RegexPattern *rePat = RegexPattern::compile(pattern, parseErr, status); | |
107 | // Note that C++ is doing an automatic conversion | |
108 | // of the (char *) pattern to a temporary | |
109 | // UnicodeString object. | |
110 | if (U_FAILURE(status)) { | |
111 | fprintf(stderr, "ugrep: error in pattern: \"%s\" at position %d\n", | |
112 | u_errorName(status), parseErr.offset); | |
113 | exit(-1); | |
114 | } | |
115 | ||
116 | // | |
117 | // Create a RegexMatcher from the newly created pattern. | |
118 | // | |
119 | UnicodeString empty; | |
120 | RegexMatcher *matcher = rePat->matcher(empty, status); | |
121 | if (U_FAILURE(status)) { | |
122 | fprintf(stderr, "ugrep: error in creating RegexMatcher: \"%s\"\n", | |
123 | u_errorName(status)); | |
124 | exit(-1); | |
125 | } | |
126 | ||
127 | // | |
128 | // Loop, processing each of the input files. | |
129 | // | |
130 | for (int fileNum=firstFileNum; fileNum < argc; fileNum++) { | |
131 | readFile(argv[fileNum]); | |
132 | ||
133 | // | |
134 | // Loop through the lines of a file, trying to match the regex pattern on each. | |
135 | // | |
136 | for (nextLine(0); lineStart<fileLen; nextLine(lineEnd)) { | |
137 | UnicodeString s(FALSE, ucharBuf+lineStart, lineEnd-lineStart); | |
138 | matcher->reset(s); | |
139 | if (matcher->find()) { | |
140 | matchFound = TRUE; | |
141 | printMatch(); | |
142 | } | |
143 | } | |
144 | } | |
145 | ||
146 | // | |
147 | // Clean up | |
148 | // | |
149 | delete matcher; | |
150 | delete rePat; | |
151 | free(ucharBuf); | |
152 | free(charBuf); | |
153 | ucnv_close(outConverter); | |
154 | ||
155 | u_cleanup(); // shut down ICU, release any cached data it owns. | |
156 | ||
157 | return matchFound? 0: 1; | |
158 | } | |
159 | ||
160 | ||
161 | ||
162 | //------------------------------------------------------------------------------------------ | |
163 | // | |
164 | // doOptions Run through the command line options, and set | |
165 | // the global variables accordingly. | |
166 | // | |
167 | // exit without returning if an error occured and | |
168 | // ugrep should not proceed further. | |
169 | // | |
170 | //------------------------------------------------------------------------------------------ | |
171 | void processOptions(int argc, const char **argv) { | |
172 | int optInd; | |
173 | UBool doUsage = FALSE; | |
174 | UBool doVersion = FALSE; | |
175 | const char *arg; | |
176 | ||
177 | ||
178 | for(optInd = 1; optInd < argc; ++optInd) { | |
179 | arg = argv[optInd]; | |
180 | ||
181 | /* version info */ | |
182 | if(strcmp(arg, "-V") == 0 || strcmp(arg, "--version") == 0) { | |
183 | doVersion = TRUE; | |
184 | } | |
185 | /* usage info */ | |
186 | else if(strcmp(arg, "--help") == 0) { | |
187 | doUsage = TRUE; | |
188 | } | |
189 | else if(strcmp(arg, "-n") == 0 || strcmp(arg, "--line-number") == 0) { | |
190 | displayLineNum = TRUE; | |
191 | } | |
192 | /* POSIX.1 says all arguments after -- are not options */ | |
193 | else if(strcmp(arg, "--") == 0) { | |
194 | /* skip the -- */ | |
195 | ++optInd; | |
196 | break; | |
197 | } | |
198 | /* unrecognized option */ | |
199 | else if(strncmp(arg, "-", strlen("-")) == 0) { | |
200 | printf("ugrep: invalid option -- %s\n", arg+1); | |
201 | doUsage = TRUE; | |
202 | } | |
203 | /* done with options */ | |
204 | else { | |
205 | break; | |
206 | } | |
207 | } | |
208 | ||
209 | if (doUsage) { | |
210 | printUsage(); | |
211 | exit(0); | |
212 | } | |
213 | ||
214 | if (doVersion) { | |
215 | printf("ugrep version 0.01\n"); | |
216 | if (optInd == argc) { | |
217 | exit(0); | |
218 | } | |
219 | } | |
220 | ||
221 | int remainingArgs = argc-optInd; // pattern file ... | |
222 | if (remainingArgs < 2) { | |
223 | fprintf(stderr, "ugrep: files or pattern are missing.\n"); | |
224 | printUsage(); | |
225 | exit(1); | |
226 | } | |
227 | ||
228 | if (remainingArgs > 2) { | |
229 | // More than one file to be processed. Display file names with match output. | |
230 | displayFileName = TRUE; | |
231 | } | |
232 | ||
233 | pattern = argv[optInd]; | |
234 | firstFileNum = optInd+1; | |
235 | } | |
236 | ||
237 | //------------------------------------------------------------------------------------------ | |
238 | // | |
239 | // printUsage | |
240 | // | |
241 | //------------------------------------------------------------------------------------------ | |
242 | void printUsage() { | |
243 | printf("ugrep [options] pattern file...\n" | |
244 | " -V or --version display version information\n" | |
245 | " --help display this help and exit\n" | |
246 | " -- stop further option processing\n" | |
247 | "-n, --line-number Prefix each line of output with the line number within its input file.\n" | |
248 | ); | |
249 | exit(0); | |
250 | } | |
251 | ||
252 | //------------------------------------------------------------------------------------------ | |
253 | // | |
254 | // readFile Read a file into memory, and convert it to Unicode. | |
255 | // | |
256 | // Since this is just a demo program, take the simple minded approach | |
257 | // of always reading the whole file at once. No intelligent buffering | |
258 | // is done. | |
259 | // | |
260 | //------------------------------------------------------------------------------------------ | |
261 | void readFile(const char *name) { | |
262 | ||
263 | // | |
264 | // Initialize global file variables | |
265 | // | |
266 | fileName = name; | |
267 | fileLen = 0; // zero length prevents processing in case of errors. | |
268 | ||
269 | ||
270 | // | |
271 | // Open the file and determine its size. | |
272 | // | |
273 | FILE *file = fopen(name, "rb"); | |
274 | if (file == 0 ) { | |
275 | fprintf(stderr, "ugrep: Could not open file \"%s\"\n", fileName); | |
276 | return; | |
277 | } | |
278 | fseek(file, 0, SEEK_END); | |
279 | int rawFileLen = ftell(file); | |
280 | fseek(file, 0, SEEK_SET); | |
281 | ||
282 | ||
283 | // | |
284 | // Read in the file | |
285 | // | |
286 | charBuf = (char *)realloc(charBuf, rawFileLen+1); // Need error checking... | |
287 | int t = fread(charBuf, 1, rawFileLen, file); | |
288 | if (t != rawFileLen) { | |
289 | fprintf(stderr, "Error reading file \"%s\"\n", fileName); | |
729e4ab9 | 290 | fclose(file); |
b75a7d8f A |
291 | return; |
292 | } | |
293 | charBuf[rawFileLen]=0; | |
294 | fclose(file); | |
295 | ||
296 | // | |
297 | // Look for a Unicode Signature (BOM) in the data | |
298 | // | |
299 | int32_t signatureLength; | |
300 | const char * charDataStart = charBuf; | |
301 | UErrorCode status = U_ZERO_ERROR; | |
302 | const char* encoding = ucnv_detectUnicodeSignature( | |
303 | charDataStart, rawFileLen, &signatureLength, &status); | |
304 | if (U_FAILURE(status)) { | |
305 | fprintf(stderr, "ugrep: ICU Error \"%s\" from ucnv_detectUnicodeSignature()\n", | |
306 | u_errorName(status)); | |
307 | return; | |
308 | } | |
309 | if(encoding!=NULL ){ | |
310 | charDataStart += signatureLength; | |
311 | rawFileLen -= signatureLength; | |
312 | } | |
313 | ||
314 | // | |
315 | // Open a converter to take the file to UTF-16 | |
316 | // | |
317 | UConverter* conv; | |
318 | conv = ucnv_open(encoding, &status); | |
319 | if (U_FAILURE(status)) { | |
320 | fprintf(stderr, "ugrep: ICU Error \"%s\" from ucnv_open()\n", u_errorName(status)); | |
321 | return; | |
322 | } | |
323 | ||
324 | // | |
325 | // Convert the file data to UChar. | |
326 | // Preflight first to determine required buffer size. | |
327 | // | |
328 | uint32_t destCap = ucnv_toUChars(conv, | |
329 | NULL, // dest, | |
330 | 0, // destCapacity, | |
331 | charDataStart, | |
332 | rawFileLen, | |
333 | &status); | |
334 | if (status != U_BUFFER_OVERFLOW_ERROR) { | |
335 | fprintf(stderr, "ugrep: ucnv_toUChars: ICU Error \"%s\"\n", u_errorName(status)); | |
336 | return; | |
337 | }; | |
338 | ||
339 | status = U_ZERO_ERROR; | |
340 | ucharBuf = (UChar *)realloc(ucharBuf, (destCap+1) * sizeof(UChar)); | |
341 | ucnv_toUChars(conv, | |
342 | ucharBuf, // dest, | |
343 | destCap+1, | |
344 | charDataStart, | |
345 | rawFileLen, | |
346 | &status); | |
347 | if (U_FAILURE(status)) { | |
348 | fprintf(stderr, "ugrep: ucnv_toUChars: ICU Error \"%s\"\n", u_errorName(status)); | |
349 | return; | |
350 | }; | |
351 | ucnv_close(conv); | |
352 | ||
353 | // | |
354 | // Successful conversion. Set the global size variables so that | |
355 | // the rest of the processing will proceed for this file. | |
356 | // | |
357 | fileLen = destCap; | |
358 | } | |
359 | ||
360 | ||
361 | ||
362 | ||
363 | ||
364 | //------------------------------------------------------------------------------------------ | |
365 | // | |
366 | // nextLine Advance the line index variables, starting at the | |
367 | // specified position in the input file buffer, by | |
368 | // scanning forwrd until the next end-of-line. | |
369 | // | |
370 | // Need to take into account all of the possible Unicode | |
371 | // line ending sequences. | |
372 | // | |
373 | //------------------------------------------------------------------------------------------ | |
374 | void nextLine(int startPos) { | |
375 | if (startPos == 0) { | |
376 | lineNum = 0; | |
377 | } else { | |
378 | lineNum++; | |
379 | } | |
380 | lineStart = lineEnd = startPos; | |
381 | ||
382 | for (;;) { | |
383 | if (lineEnd >= fileLen) { | |
384 | return; | |
385 | } | |
386 | UChar c = ucharBuf[lineEnd]; | |
387 | lineEnd++; | |
388 | if (c == 0x0a || // Line Feed | |
389 | c == 0x0c || // Form Feed | |
390 | c == 0x0d || // Carriage Return | |
391 | c == 0x85 || // Next Line | |
392 | c == 0x2028 || // Line Separator | |
393 | c == 0x2029) // Paragraph separator | |
394 | { | |
395 | break; | |
396 | } | |
397 | } | |
398 | ||
399 | // Check for CR/LF sequence, and advance over the LF if we're in the middle of one. | |
400 | if (lineEnd < fileLen && | |
401 | ucharBuf[lineEnd-1] == 0x0d && | |
402 | ucharBuf[lineEnd] == 0x0a) | |
403 | { | |
404 | lineEnd++; | |
405 | } | |
406 | } | |
407 | ||
408 | ||
409 | //------------------------------------------------------------------------------------------ | |
410 | // | |
411 | // printMatch Called when a matching line has been located. | |
412 | // Print out the line from the file with the match, after | |
413 | // converting it back to the default code page. | |
414 | // | |
415 | //------------------------------------------------------------------------------------------ | |
416 | void printMatch() { | |
417 | char buf[2000]; | |
418 | UErrorCode status = U_ZERO_ERROR; | |
419 | ||
420 | // If we haven't already created a converter for output, do it now. | |
421 | if (outConverter == 0) { | |
422 | outConverter = ucnv_open(NULL, &status); | |
423 | if (U_FAILURE(status)) { | |
424 | fprintf(stderr, "ugrep: Error opening default converter: \"%s\"\n", | |
425 | u_errorName(status)); | |
426 | exit(-1); | |
427 | } | |
428 | }; | |
429 | ||
430 | // Convert the line to be printed back to the default 8 bit code page. | |
431 | // If the line is too long for our buffer, just truncate it. | |
432 | ucnv_fromUChars(outConverter, | |
433 | buf, // destination buffer for conversion | |
434 | sizeof(buf), // capacity of destination buffer | |
435 | &ucharBuf[lineStart], // Input to conversion | |
436 | lineEnd-lineStart, // number of UChars to convert | |
437 | &status); | |
438 | buf[sizeof(buf)-1] = 0; // Add null for use in case of too long lines. | |
439 | // The converter null-terminates its output unless | |
440 | // the buffer completely fills. | |
441 | ||
442 | if (displayFileName) { | |
443 | printf("%s:", fileName); | |
444 | } | |
445 | if (displayLineNum) { | |
446 | printf("%d:", lineNum); | |
447 | } | |
448 | printf("%s", buf); | |
449 | } | |
450 |