Added -clobber switch to mhstore(1) [Bug #11160].
[mmh] / docs / historical / mh-6.8.5 / miscellany / less-177 / search.c
1 /*
2  * Routines to search a file for a pattern.
3  */
4
5 #include "less.h"
6 #include "position.h"
7 #if REGCOMP
8 #include "regexp.h"
9 #endif
10
11 extern int sigs;
12 extern int how_search;
13 extern int caseless;
14 extern int linenums;
15 extern int jump_sline;
16
17 /*
18  * Search for the n-th occurrence of a specified pattern, 
19  * either forward or backward.
20  * Return the number of matches not yet found in this file
21  * (that is, n minus the number of matches found).
22  * Return -1 if the search should be aborted.
23  * Caller may continue the search in another file 
24  * if less than n matches are found in this file.
25  */
26         public int
27 search(search_type, pattern, n)
28         int search_type;
29         char *pattern;
30         int n;
31 {
32         POSITION pos, linepos, oldpos;
33         register char *p;
34         register char *q;
35         register int goforw;
36         register int want_match;
37         char *line;
38         int linenum;
39         int line_match;
40         static int is_caseless;
41 #if RECOMP
42         char *re_comp();
43         PARG parg;
44 #else
45 #if REGCMP
46         char *regcmp();
47         static char *cpattern = NULL;
48 #else
49 #if REGCOMP
50         static struct regexp *regpattern = NULL;
51 #else
52         static char lpbuf[100];
53         static char *last_pattern = NULL;
54 #endif
55 #endif
56 #endif
57
58         /*
59          * Extract flags and type of search.
60          */
61         goforw = (SRCH_DIR(search_type) == SRCH_FORW);
62         want_match = !(search_type & SRCH_NOMATCH);
63
64         if (pattern != NULL && *pattern != '\0' && (is_caseless = caseless))
65         {
66                 /*
67                  * Search will ignore case, unless
68                  * there are any uppercase letters in the pattern.
69                  */
70                 for (p = pattern;  *p != '\0';  p++)
71                         if (*p >= 'A' && *p <= 'Z')
72                         {
73                                 is_caseless = 0;
74                                 break;
75                         }
76         }
77 #if RECOMP
78
79         /*
80          * (re_comp handles a null pattern internally, 
81          *  so there is no need to check for a null pattern here.)
82          */
83         if ((parg.p_string = re_comp(pattern)) != NULL)
84         {
85                 error("%s", &parg);
86                 return (-1);
87         }
88 #else
89 #if REGCMP
90         if (pattern == NULL || *pattern == '\0')
91         {
92                 /*
93                  * A null pattern means use the previous pattern.
94                  * The compiled previous pattern is in cpattern, so just use it.
95                  */
96                 if (cpattern == NULL)
97                 {
98                         error("No previous regular expression", NULL_PARG);
99                         return (-1);
100                 }
101         } else
102         {
103                 /*
104                  * Otherwise compile the given pattern.
105                  */
106                 char *s;
107                 if ((s = regcmp(pattern, 0)) == NULL)
108                 {
109                         error("Invalid pattern", NULL_PARG);
110                         return (-1);
111                 }
112                 if (cpattern != NULL)
113                         free(cpattern);
114                 cpattern = s;
115         }
116 #else
117 #if REGCOMP
118         if (pattern == NULL || *pattern == '\0')
119         {
120                 /*
121                  * A null pattern means use the previous pattern.
122                  * The compiled previous pattern is in regpattern, 
123                  * so just use it.
124                  */
125                 if (regpattern == NULL)
126                 {
127                         error("No previous regular expression", NULL_PARG);
128                         return (-1);
129                 }
130         } else
131         {
132                 /*
133                  * Otherwise compile the given pattern.
134                  */
135                 struct regexp *s;
136                 if ((s = regcomp(pattern)) == NULL)
137                 {
138                         error("Invalid pattern", NULL_PARG);
139                         return (-1);
140                 }
141                 if (regpattern != NULL)
142                         free(regpattern);
143                 regpattern = s;
144         }
145 #else
146         if (pattern == NULL || *pattern == '\0')
147         {
148                 /*
149                  * Null pattern means use the previous pattern.
150                  */
151                 if (last_pattern == NULL)
152                 {
153                         error("No previous regular expression", NULL_PARG);
154                         return (-1);
155                 }
156                 pattern = last_pattern;
157         } else
158         {
159                 strcpy(lpbuf, pattern);
160                 last_pattern = lpbuf;
161         }
162 #endif
163 #endif
164 #endif
165
166         /*
167          * Figure out where to start the search.
168          */
169         if (empty_screen())
170         {
171                 /*
172                  * Start at the beginning (or end) of the file.
173                  * (The empty_screen() case is mainly for 
174                  * command line initiated searches;
175                  * for example, "+/xyz" on the command line.)
176                  */
177                 if (goforw)
178                         pos = ch_zero();
179                 else 
180                 {
181                         pos = ch_length();
182                         if (pos == NULL_POSITION)
183                                 pos = ch_zero();
184                 }
185         } else 
186         {
187                 if (how_search)
188                 {
189                         if (goforw)
190                                 linenum = BOTTOM_PLUS_ONE;
191                         else
192                                 linenum = TOP;
193                         pos = position(linenum);
194                 } else
195                 {
196                         linenum = adjsline(jump_sline);
197                         pos = position(linenum);
198                         if (goforw)
199                                 pos = forw_raw_line(pos, (char **)NULL);
200                 }
201         }
202
203         if (pos == NULL_POSITION)
204         {
205                 /*
206                  * Can't find anyplace to start searching from.
207                  */
208                 error("Nothing to search", NULL_PARG);
209                 return (-1);
210         }
211
212         linenum = find_linenum(pos);
213         oldpos = pos;
214         for (;;)
215         {
216                 /*
217                  * Get lines until we find a matching one or 
218                  * until we hit end-of-file (or beginning-of-file 
219                  * if we're going backwards).
220                  */
221                 if (sigs)
222                         /*
223                          * A signal aborts the search.
224                          */
225                         return (-1);
226
227                 if (goforw)
228                 {
229                         /*
230                          * Read the next line, and save the 
231                          * starting position of that line in linepos.
232                          */
233                         linepos = pos;
234                         pos = forw_raw_line(pos, &line);
235                         if (linenum != 0)
236                                 linenum++;
237                 } else
238                 {
239                         /*
240                          * Read the previous line and save the
241                          * starting position of that line in linepos.
242                          */
243                         pos = back_raw_line(pos, &line);
244                         linepos = pos;
245                         if (linenum != 0)
246                                 linenum--;
247                 }
248
249                 if (pos == NULL_POSITION)
250                 {
251                         /*
252                          * We hit EOF/BOF without a match.
253                          */
254                         return (n);
255                 }
256
257                 /*
258                  * If we're using line numbers, we might as well
259                  * remember the information we have now (the position
260                  * and line number of the current line).
261                  * Don't do it for every line because it slows down
262                  * the search.  Remember the line number only if
263                  * we're "far" from the last place we remembered it.
264                  */
265                 if (linenums && abs(pos - oldpos) > 1024)
266                 {
267                         add_lnum(linenum, pos);
268                         oldpos = pos;
269                 }
270
271                 if (is_caseless)
272                 {
273                         /*
274                          * If this is a caseless search, convert 
275                          * uppercase in the input line to lowercase.
276                          * While we're at it, remove any backspaces
277                          * along with the preceding char.
278                          * This allows us to match text which is 
279                          * underlined or overstruck.
280                          */
281                         for (p = q = line;  *p != '\0';  p++, q++)
282                         {
283                                 if (*p >= 'A' && *p <= 'Z')
284                                         /* Convert uppercase to lowercase. */
285                                         *q = *p + 'a' - 'A';
286                                 else if (q > line && *p == '\b')
287                                         /* Delete BS and preceding char. */
288                                         q -= 2;
289                                 else
290                                         /* Otherwise, just copy. */
291                                         *q = *p;
292                         }
293                 }
294
295                 /*
296                  * Test the next line to see if we have a match.
297                  * This is done in a variety of ways, depending
298                  * on what pattern matching functions are available.
299                  */
300 #if REGCMP
301                 line_match = (regex(cpattern, line) != NULL);
302 #else
303 #if RECOMP
304                 line_match = (re_exec(line) == 1);
305 #else
306 #if REGCOMP
307                 line_match = regexec(regpattern, line);
308 #else
309                 line_match = match(pattern, line);
310 #endif
311 #endif
312 #endif
313                 /*
314                  * We are successful if want_match and line_match are
315                  * both true (want a match and got it),
316                  * or both false (want a non-match and got it).
317                  */
318                 if (((want_match && line_match) || (!want_match && !line_match)) &&
319                       --n <= 0)
320                         /*
321                          * Found the line.
322                          */
323                         break;
324         }
325
326         jump_loc(linepos, jump_sline);
327         return (0);
328 }
329
330 #if (!REGCMP) && (!RECOMP) && (!REGCOMP)
331 /*
332  * We have neither regcmp() nor re_comp().
333  * We use this function to do simple pattern matching.
334  * It supports no metacharacters like *, etc.
335  */
336         static int
337 match(pattern, buf)
338         char *pattern, *buf;
339 {
340         register char *pp, *lp;
341
342         for ( ;  *buf != '\0';  buf++)
343         {
344                 for (pp = pattern, lp = buf;  *pp == *lp;  pp++, lp++)
345                         if (*pp == '\0' || *lp == '\0')
346                                 break;
347                 if (*pp == '\0')
348                         return (1);
349         }
350         return (0);
351 }
352 #endif