?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
* New version 2.21
[alpine.git] / pico / search.c
bloba8cf6033e58932c16a120dc320a39309f2eeae3c
1 #if !defined(lint) && !defined(DOS)
2 static char rcsid[] = "$Id: search.c 1266 2009-07-14 18:39:12Z hubert@u.washington.edu $";
3 #endif
4
5 /*
6 * ========================================================================
7 * Copyright 2013-2017 Eduardo Chappa
8 * Copyright 2006-2008 University of Washington
9 *
10 * Licensed under the Apache License, Version 2.0 (the "License");
11 * you may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * http://www.apache.org/licenses/LICENSE-2.0
15 *
16 * ========================================================================
17 */
18
19 /*
20 * Program: Searching routines
21 *
22 * The functions in this file implement commands that search in the forward
23 * and backward directions. There are no special characters in the search
24 * strings. Probably should have a regular expression search, or something
25 * like that.
26 *
27 */
28
29 #include "headers.h"
30
31 int eq(UCS, UCS);
32 int expandp(UCS *, UCS *, int);
33 int readnumpat(char *);
34 void get_pat_cases(UCS *, UCS *);
35 int srpat(char *, UCS *, size_t, int, int);
36 int readpattern(char *, int, int);
37 int replace_pat(UCS *, int *, int);
38 int replace_all(UCS *, UCS *, int);
39 void reverse_line(LINE *);
40 void reverse_buffer(void);
41 void reverse_ucs4(UCS *);
42 void reverse_all(UCS *, int);
43 void supdate(UCS *, int);
44 char *sucs4_to_utf8_cpystr(UCS *, int);
45
46 #define FWS_RETURN(RV) { \
47 thisflag |= CFSRCH; \
48 curwp->w_flag |= WFMODE; \
49 sgarbk = TRUE; \
50 return(RV); \
51 }
52
53 /* The search menu leaves a number of keys free, some are taken
54 * as subcommands of the search command, and some are taken are
55 * editing commands. This leaves the following keys open:
56 * ^J, ^N, ^O, ^P, ^R, ^T, ^U, ^V, ^W, ^X and ^Y.
57 * Out of these keys, ^J, ^N, ^P and ^X are not defined as commands, however,
58 * in some patches ^N, ^P and ^X are defined. ^N is defined as part of
59 * an editing command, ^P and ^X are defined to delete paragraphs and to
60 * remove text to the end of file, so only ^J is undefined.
61 */
62
63 #define REPLACE_KEY 2 /* the location of the replace key in the array below */
64
65 EXTRAKEYS menu_srchpat[] = {
66 {"^Y", N_("FirstLine"), (CTRL|'Y')},
67 {"^V", N_("LastLine"), (CTRL|'V')},
68 {"^R", N_("No Replace"), (CTRL|'R')},
69 {"^^", N_("Optns Menu"), (CTRL|'^')}, /* toggle this menu or options menu */
70 {"^T", N_("LineNumber"), (CTRL|'T')},
71 {"^W", N_("Start of Para"), (CTRL|'W')},
72 {"^O", N_("End of Para"), (CTRL|'O')},
73 {"^U", N_("FullJustify"), (CTRL|'U')},
74 {NULL, NULL, 0},
75 {NULL, NULL, 0}
76 };
77
78 #define EXACTSR_KEY 1 /* toggle an exact or approximate search */
79 #define BGNLINE_KEY 3 /* the location of Bgn Line command in the array below */
80 #define ENDLINE_KEY 4 /* the location of End Line command in the array below */
81 #define BSEARCH_KEY 5 /* the location of the bsearch key in the array below */
82 EXTRAKEYS menu_srchopt[] = {
83 {"^^", N_("Orig Menu"), (CTRL|'^')}, /* toggle original or options menu */
84 {"^X", N_("Exact"), (CTRL|'X')}, /* toggle exact vs non exact */
85 {"^R", N_("No Replace"), (CTRL|'R')}, /* toggle replace or not replace */
86 {"^V", N_("Bgn Line"), (CTRL|'V')}, /* toggle Bgn Line or anywhere */
87 {"^N", N_("End Line"), (CTRL|'N')}, /* toggle End Line or anywhere */
88 {"^P", N_("BackSearch"), (CTRL|'P')}, /* toggle Backward or forward */
89 {NULL, NULL, 0},
90 {NULL, NULL, 0},
91 {NULL, NULL, 0},
92 {NULL, NULL, 0}
93 };
94
95 /*
96 * Search forward. Get a search string from the user, and search, beginning at
97 * ".", for the string. If found, reset the "." to be just after the match
98 * string, and [perhaps] repaint the display. Bound to "C-S".
99 */
100
101 /* string search input parameters */
102
103 #define PTBEG 1 /* leave the point at the begining on search */
104 #define PTEND 2 /* leave the point at the end on search */
105
106 #define NPMT (2*NLINE+32)
107
108
109 static char *SearchHelpText[] = {
110 /* TRANSLATORS: Some help text that goes together in a group. */
111 N_("Help for Search Command"),
112 " ",
113 N_(" Enter the words or characters you would like to search"),
114 N_("~ for, then press ~R~e~t~u~r~n. The search then takes place."),
115 N_(" When the characters or words that you entered "),
116 N_(" are found, the buffer will be redisplayed with the cursor "),
117 N_(" at the beginning of the selected text."),
118 " ",
119 N_(" The most recent string for which a search was made is"),
120 N_(" displayed in the \"Search\" prompt between the square"),
121 N_(" brackets. This string is the default search prompt."),
122 N_("~ Hitting only ~R~e~t~u~r~n or at the prompt will cause the"),
123 N_(" search to be made with the default value."),
124 " ",
125 N_(" The text search is not case sensitive, and will examine the"),
126 N_(" entire message."),
127 " ",
128 N_(" Should the search fail, a message will be displayed."),
129 " ",
130 N_("End of Search Help."),
131 " ",
132 NULL
133 };
134
135
136 /*
137 * Compare two characters. The "bc" comes from the buffer. It has it's case
138 * folded out. The "pc" is from the pattern.
139 */
140 int
141 eq(UCS bc, UCS pc)
142 {
143 if ((curwp->w_bufp->b_mode & MDEXACT) == 0){
144 if (bc>='a' && bc<='z')
145 bc -= 0x20;
146
147 if (pc>='a' && pc<='z')
148 pc -= 0x20;
149 }
150
151 return(bc == pc);
152 }
153
154
155 int
156 forwsearch(int f, int n)
157 {
158 int status, flags;
159 int wrapt = FALSE, wrapt2 = FALSE;
160 int repl_mode = FALSE;
161 UCS defpat[NPAT];
162 int search = FALSE;
163 EML eml;
164
165
166 /* resolve the repeat count */
167 if (n == 0)
168 n = 1;
169
170 if (n < 1) /* search backwards */
171 FWS_RETURN(0);
172
173 defpat[0] = '\0';
174 /* defaults: usual menu, search forward, not case sensitive */
175
176 flags = SR_ORIGMEN | SR_FORWARD;
177
178 /* exact search is sticky -- that is, once one is done, so will be
179 * the next ones. This is consistent with all all searches being
180 * case insensitive by default.
181 */
182 if((curwp->w_bufp->b_mode & MDEXACT) == 0)
183 flags |= SR_NOEXACT;
184 else
185 flags |= SR_EXACTSR;
186
187 /* ask the user for the text of a pattern */
188 while(1){
189
190 if (gmode & MDREPLACE)
191 status = srpat("Search", defpat, NPAT, repl_mode, flags);
192 else
193 status = readpattern("Search", TRUE, flags);
194
195 switch(status){
196 case TRUE: /* user typed something */
197 search = TRUE;
198 break;
199
200 case HELPCH: /* help requested */
201 if(Pmaster){
202 VARS_TO_SAVE *saved_state;
203
204 saved_state = save_pico_state();
205 (*Pmaster->helper)(Pmaster->search_help,
206 _("Help for Searching"), 1);
207 if(saved_state){
208 restore_pico_state(saved_state);
209 free_pico_state(saved_state);
210 }
211 }
212 else
213 pico_help(SearchHelpText, _("Help for Searching"), 1);
214
215 case (CTRL|'L'): /* redraw requested */
216 pico_refresh(FALSE, 1);
217 update();
218 break;
219
220
221 case (CTRL|'P'):
222 if(flags & SR_ORIGMEN){
223 /* Undefined still */
224 }
225 if(flags & SR_OPTNMEN){
226 if(flags & SR_FORWARD){
227 flags &= ~SR_FORWARD;
228 flags |= SR_BACKWRD;
229 } else {
230 flags &= ~SR_BACKWRD;
231 flags |= SR_FORWARD;
232 }
233 }
234 break;
235
236 case (CTRL|'V'):
237 if(flags & SR_ORIGMEN){
238 gotoeob(0, 1);
239 mlerase();
240 FWS_RETURN(TRUE);
241 } else if (flags & SR_OPTNMEN){
242 if(flags & SR_ENDLINE)
243 flags &= ~SR_ENDLINE;
244 if(flags & SR_BEGLINE)
245 flags &= ~SR_BEGLINE;
246 else
247 flags |= SR_BEGLINE;
248 }
249 break;
250
251 case (CTRL|'N'):
252 if(flags & SR_ORIGMEN){
253 /* undefined still */
254 } else if (flags & SR_OPTNMEN){
255 if(flags & SR_BEGLINE)
256 flags &= ~SR_BEGLINE;
257 if(flags & SR_ENDLINE)
258 flags &= ~SR_ENDLINE;
259 else
260 flags |= SR_ENDLINE;
261 }
262 break;
263
264 case (CTRL|'Y'):
265 if(flags & SR_ORIGMEN){
266 gotobob(0, 1);
267 mlerase();
268 FWS_RETURN(TRUE);
269 }
270
271 case (CTRL|'^'):
272 if (flags & SR_ORIGMEN){
273 flags &= ~SR_ORIGMEN;
274 flags |= SR_OPTNMEN;
275 } else {
276 flags &= ~SR_OPTNMEN;
277 flags |= SR_ORIGMEN;
278 }
279 break;
280
281 case (CTRL|'X'):
282 if(flags & SR_OPTNMEN){
283 if (flags & SR_NOEXACT){
284 flags &= ~SR_NOEXACT;
285 flags |= SR_EXACTSR;
286 } else {
287 flags &= ~SR_EXACTSR;
288 flags |= SR_NOEXACT;
289 }
290 if((curwp->w_bufp->b_mode & MDEXACT) == 0)
291 curwp->w_bufp->b_mode |= MDEXACT;
292 else
293 curwp->w_bufp->b_mode &= ~MDEXACT;
294 }
295 break;
296
297 case (CTRL|'T') :
298 if(flags & SR_ORIGMEN){
299 switch(status = readnumpat(_("Search to Line Number : "))){
300 case -1 :
301 emlwrite(_("Search to Line Number Cancelled"), NULL);
302 FWS_RETURN(FALSE);
303
304 case 0 :
305 emlwrite(_("Line number must be greater than zero"), NULL);
306 FWS_RETURN(FALSE);
307
308 case -2 :
309 emlwrite(_("Line number must contain only digits"), NULL);
310 FWS_RETURN(FALSE);
311
312 case -3 :
313 continue;
314
315 default :
316 gotoline(0, status);
317 mlerase();
318 FWS_RETURN(TRUE);
319 }
320 }
321 break;
322
323 case (CTRL|'W'):
324 if(flags & SR_ORIGMEN){
325 LINE *linep = curwp->w_dotp;
326 int offset = curwp->w_doto;
327
328 gotobop(0, 1);
329 gotobol(0, 1);
330
331 /*
332 * if we're asked to backup and we're already
333 *
334 */
335 if((lastflag & CFSRCH)
336 && linep == curwp->w_dotp
337 && offset == curwp->w_doto
338 && !(offset == 0 && lback(linep) == curbp->b_linep)){
339 backchar(0, 1);
340 gotobop(0, 1);
341 gotobol(0, 1);
342 }
343 mlerase();
344 FWS_RETURN(TRUE);
345 }
346 break;
347
348 case (CTRL|'O'):
349 if(flags & SR_ORIGMEN){
350 if(curwp->w_dotp != curbp->b_linep){
351 gotoeop(0, 1);
352 forwchar(0, 1);
353 }
354 mlerase();
355 FWS_RETURN(TRUE);
356 }
357 break;
358
359 case (CTRL|'U'):
360 if(flags & SR_ORIGMEN){
361 fillbuf(0, 1);
362 mlerase();
363 FWS_RETURN(TRUE);
364 }
365 break;
366
367 case (CTRL|'R'): /* toggle replacement option */
368 repl_mode = !repl_mode;
369 break;
370
371 default:
372 if(status == ABORT)
373 emlwrite(_("Search Cancelled"), NULL);
374 else
375 mlerase();
376
377 FWS_RETURN(FALSE);
378 }
379
380 /* replace option is disabled */
381 if (!(gmode & MDREPLACE)){
382 ucs4_strncpy(defpat, pat, NPAT);
383 defpat[NPAT-1] = '\0';
384 break;
385 }
386 else if (search){ /* search now */
387 ucs4_strncpy(pat, defpat, NPAT); /* remember this search for the future */
388 pat[NPAT-1] = '\0';
389 break;
390 }
391 }
392
393 reverse_all(defpat, flags & SR_BACKWRD);
394
395 /*
396 * This code is kind of dumb. What I want is successive C-W 's to
397 * move dot to successive occurences of the pattern. So, if dot is
398 * already sitting at the beginning of the pattern, then we'll move
399 * forward a char before beginning the search. We'll let the
400 * automatic wrapping handle putting the dot back in the right
401 * place...
402 */
403 status = 0; /* using "status" as int temporarily! */
404 while(1){
405 if(defpat[status] == '\0'){
406 forwchar(0, 1);
407 break;
408 }
409
410 if(status + curwp->w_doto >= llength(curwp->w_dotp) ||
411 !eq(defpat[status],lgetc(curwp->w_dotp, curwp->w_doto + status).c))
412 break;
413 status++;
414 }
415
416 /* search for the pattern */
417
418 while (n-- > 0) {
419 if((status = forscan(&wrapt,defpat, flags, NULL,0,PTBEG)) == FALSE)
420 break;
421 }
422
423 /* and complain if not there */
424 if (status == FALSE){
425 char *utf8;
426 UCS x[1];
427
428 x[0] = '\0';
429
430 utf8 = sucs4_to_utf8_cpystr(defpat ? defpat : x, flags & SR_BACKWRD);
431 /* TRANSLATORS: reporting the result of a failed search */
432 eml.s = utf8;
433 emlwrite(_("\"%s\" not found"), &eml);
434 if(utf8)
435 fs_give((void **) &utf8);
436 }
437 else if((gmode & MDREPLACE) && repl_mode == TRUE){
438 status = replace_pat(defpat, &wrapt2, flags & SR_BACKWRD); /* replace pattern */
439 if (wrapt == TRUE || wrapt2 == TRUE){
440 eml.s = (status == ABORT) ? "cancelled but wrapped" : "Wrapped";
441 emlwrite("Replacement %s", &eml);
442 }
443 }
444 else if(wrapt == TRUE){
445 emlwrite("Search Wrapped", NULL);
446 }
447 else if(status == TRUE){
448 emlwrite("", NULL);
449 }
450
451 reverse_all(defpat, flags & SR_BACKWRD);
452 if(curwp->w_doto == -1){
453 curwp->w_doto = 0;
454 curwp->w_flag |= WFMOVE;
455 }
456 FWS_RETURN(status);
457 }
458
459
460 /* Replace a pattern with the pattern the user types in one or more times. */
461 int
462 replace_pat(UCS *defpat, int *wrapt, int bsearch)
463 {
464 register int status;
465 UCS lpat[NPAT], origpat[NPAT]; /* case sensitive pattern */
466 EXTRAKEYS menu_pat[12];
467 int repl_all = FALSE;
468 UCS *b;
469 char utf8tmp[NPMT];
470 UCS prompt[NPMT];
471 UCS *promptp;
472 int i, flags;
473
474 if(bsearch){
475 flags = SR_BACKWRD;
476 curwp->w_doto -= ucs4_strlen(defpat) - 1;
477 }
478 else flags = SR_FORWARD;
479
480 forscan(wrapt, defpat, flags, NULL, 0, PTBEG); /* go to word to be replaced */
481
482 lpat[0] = '\0';
483 memset((void *)&menu_pat, 0, sizeof(menu_pat));
484 /* additional 'replace all' menu option */
485 menu_pat[0].name = "^X";
486 menu_pat[0].key = (CTRL|'X');
487 menu_pat[0].label = N_("Repl All");
488 KS_OSDATASET(&menu_pat[0], KS_NONE);
489
490 while(1) {
491
492 /* we need to reverse the buffer back to its original state, so that
493 * the user will not see that we reversed it under them. The cursor
494 * is at the beginning of the reverse string, that is at the end
495 * of the string. Move it back to the beginning.
496 */
497
498 reverse_all(defpat, bsearch); /* reverse for normal view */
499 update();
500 (*term.t_rev)(1);
501 get_pat_cases(origpat, defpat);
502 pputs(origpat, 1); /* highlight word */
503 (*term.t_rev)(0);
504
505 snprintf(utf8tmp, NPMT, "Replace%s \"", repl_all ? " every" : "");
506 b = utf8_to_ucs4_cpystr(utf8tmp);
507 if(b){
508 ucs4_strncpy(prompt, b, NPMT);
509 prompt[NPMT-1] = '\0';
510 fs_give((void **) &b);
511 }
512
513 promptp = &prompt[ucs4_strlen(prompt)];
514
515 expandp(defpat, promptp, NPMT-(promptp-prompt));
516 prompt[NPMT-1] = '\0';
517 promptp += ucs4_strlen(promptp);
518
519 b = utf8_to_ucs4_cpystr("\" with");
520 if(b){
521 ucs4_strncpy(promptp, b, NPMT-(promptp-prompt));
522 promptp += ucs4_strlen(promptp);
523 prompt[NPMT-1] = '\0';
524 fs_give((void **) &b);
525 }
526
527 if(rpat[0] != '\0'){
528 if((promptp-prompt) < NPMT-2){
529 *promptp++ = ' ';
530 *promptp++ = '[';
531 *promptp = '\0';
532 }
533
534 expandp(rpat, promptp, NPMT-(promptp-prompt));
535 prompt[NPMT-1] = '\0';
536 promptp += ucs4_strlen(promptp);
537
538 if((promptp-prompt) < NPMT-1){
539 *promptp++ = ']';
540 *promptp = '\0';
541 }
542 }
543
544 if((promptp-prompt) < NPMT-3){
545 *promptp++ = ' ';
546 *promptp++ = ':';
547 *promptp++ = ' ';
548 *promptp = '\0';
549 }
550
551 prompt[NPMT-1] = '\0';
552
553 status = mlreplyd(prompt, lpat, NPAT, QDEFLT, menu_pat);
554
555 curwp->w_flag |= WFMOVE;
556
557 reverse_all(defpat, bsearch); /* reverse for internal use */
558
559 switch(status){
560
561 case TRUE :
562 case FALSE :
563 if(lpat[0]){
564 ucs4_strncpy(rpat, lpat, NPAT); /* remember default */
565 rpat[NPAT-1] = '\0';
566 }
567 else{
568 ucs4_strncpy(lpat, rpat, NPAT); /* use default */
569 lpat[NPAT-1] = '\0';
570 }
571
572 if (repl_all){
573 status = replace_all(defpat, lpat, bsearch);
574 }
575 else{
576 if(bsearch)
577 curwp->w_doto -= ucs4_strlen(defpat) - 1;
578 chword(defpat, lpat, bsearch); /* replace word */
579 /* after substitution the cursor is past the end of the
580 * replaced string, so we backdown in backward search,
581 * to make it appear at the beginning of the replaced string.
582 * We make this choice in case the next search is backward,
583 * because if we put the cursor at the end, the next backward
584 * search might hit the substituted string, and we want to
585 * avoid that, because we probably do not want to substitute
586 * the new string, but old text.
587 */
588 if(bsearch && (lback(curwp->w_dotp) != curbp->b_linep
589 || curwp->w_doto > 0))
590 curwp->w_doto--;
591 supdate(defpat, bsearch);
592 status = TRUE;
593 }
594
595 if(status == TRUE)
596 emlwrite("", NULL);
597
598 return(status);
599
600 case HELPCH: /* help requested */
601 if(Pmaster){
602 VARS_TO_SAVE *saved_state;
603
604 saved_state = save_pico_state();
605 (*Pmaster->helper)(Pmaster->search_help,
606 _("Help for Searching"), 1);
607 if(saved_state){
608 restore_pico_state(saved_state);
609 free_pico_state(saved_state);
610 }
611 }
612 else
613 pico_help(SearchHelpText, _("Help for Searching"), 1);
614
615 case (CTRL|'L'): /* redraw requested */
616 pico_refresh(FALSE, 1);
617 update();
618 break;
619
620 case (CTRL|'X'): /* toggle replace all option */
621 if (repl_all){
622 repl_all = FALSE;
623 /* TRANSLATORS: abbreviation for Replace All occurences */
624 menu_pat[0].label = N_("Repl All");
625 }
626 else{
627 repl_all = TRUE;
628 /* TRANSLATORS: Replace just one occurence */
629 menu_pat[0].label = N_("Repl One");
630 }
631
632 break;
633
634 default:
635 if(status == ABORT){
636 emlwrite(_("Replacement Cancelled"), NULL);
637 reverse_all(defpat, bsearch); /* undo reverse buffer and pattern */
638 pico_refresh(FALSE, 1);
639 reverse_all(defpat, bsearch); /* reverse buffer and pattern */
640 }
641 else{
642 mlerase();
643 chword(defpat, origpat, bsearch);
644 }
645
646 supdate(defpat, bsearch);
647 return(FALSE);
648 }
649 }
650 }
651
652
653 /* Since the search is not case sensitive, we must obtain the actual pattern
654 that appears in the text, so that we can highlight (and unhighlight) it
655 without using the wrong cases */
656 void
657 get_pat_cases(UCS *realpat, UCS *searchpat)
658 {
659 int i, searchpatlen, curoff;
660
661 curoff = curwp->w_doto;
662 searchpatlen = ucs4_strlen(searchpat);
663
664 for (i = 0; i < searchpatlen; i++)
665 realpat[i] = lgetc(curwp->w_dotp, curoff++).c;
666
667 realpat[searchpatlen] = '\0';
668 }
669
670
671 /* Ask the user about every occurence of orig pattern and replace it with a
672 repl pattern if the response is affirmative. */
673 int
674 replace_all(UCS *orig, UCS *repl, int bsearch)
675 {
676 register int status = 0;
677 UCS *b;
678 UCS realpat[NPAT];
679 char utf8tmp[NPMT];
680 UCS *promptp;
681 UCS prompt[NPMT];
682 int wrapt, n = 0;
683 LINE *stop_line = curwp->w_dotp;
684 int stop_offset = curwp->w_doto;
685 EML eml;
686 int flags;
687
688 /* similar to replace_pat. When we come here, if bsearch is set,
689 * the cursor is at the end of the match, so we must bring it back
690 * to the beginning.
691 */
692 if(bsearch){
693 flags = SR_BACKWRD;
694 curwp->w_doto -= ucs4_strlen(orig) - 1;
695 curwp->w_flag |= WFMOVE;
696 }
697 else
698 flags = SR_FORWARD;
699
700 stop_offset = curwp->w_doto;
701 while (1)
702 if (forscan(&wrapt, orig, flags, stop_line, stop_offset, PTBEG)){
703 curwp->w_flag |= WFMOVE; /* put cursor back */
704
705 reverse_all(orig, bsearch); /* undo reverse buffer and pattern */
706 update();
707 (*term.t_rev)(1);
708 get_pat_cases(realpat, orig);
709 pputs(realpat, 1); /* highlight word */
710 (*term.t_rev)(0);
711 fflush(stdout);
712
713 snprintf(utf8tmp, NPMT, "Replace \"");
714 b = utf8_to_ucs4_cpystr(utf8tmp);
715 if(b){
716 ucs4_strncpy(prompt, b, NPMT);
717 prompt[NPMT-1] = '\0';
718 fs_give((void **) &b);
719 }
720
721 promptp = &prompt[ucs4_strlen(prompt)];
722
723 expandp(orig, promptp, NPMT-(promptp-prompt));
724 reverse_all(orig, bsearch); /* reverse for internal use */
725 prompt[NPMT-1] = '\0';
726 promptp += ucs4_strlen(promptp);
727
728 b = utf8_to_ucs4_cpystr("\" with \"");
729 if(b){
730 ucs4_strncpy(promptp, b, NPMT-(promptp-prompt));
731 promptp += ucs4_strlen(promptp);
732 prompt[NPMT-1] = '\0';
733 fs_give((void **) &b);
734 }
735
736 expandp(repl, promptp, NPMT-(promptp-prompt));
737 prompt[NPMT-1] = '\0';
738 promptp += ucs4_strlen(promptp);
739
740 if((promptp-prompt) < NPMT-1){
741 *promptp++ = '\"';
742 *promptp = '\0';
743 }
744
745 prompt[NPMT-1] = '\0';
746
747 status = mlyesno(prompt, TRUE); /* ask user */
748
749 if(bsearch){
750 curwp->w_doto -= ucs4_strlen(realpat) - 1;
751 curwp->w_flag |= WFMOVE;
752 }
753 if (status == TRUE){
754 n++;
755 chword(realpat, repl, bsearch); /* replace word */
756 supdate(realpat, bsearch);
757 }else{
758 chword(realpat, realpat, bsearch); /* replace word by itself */
759 supdate(realpat, bsearch);
760 if(status == ABORT){ /* if cancelled return */
761 eml.s = comatose(n);
762 emlwrite("Replace All cancelled after %s changes", &eml);
763 return (ABORT); /* ... else keep looking */
764 }
765 }
766 }
767 else{
768 char *utf8;
769
770 utf8 = sucs4_to_utf8_cpystr(orig, bsearch);
771 if(utf8){
772 eml.s = utf8;
773 emlwrite(_("No more matches for \"%s\""), &eml);
774 fs_give((void **) &utf8);
775 }
776 else
777 emlwrite(_("No more matches"), NULL);
778
779 return (FALSE);
780 }
781 }
782
783
784 /* Read a replacement pattern. Modeled after readpattern(). */
785 int
786 srpat(char *utf8prompt, UCS *defpat, size_t defpatlen, int repl_mode, int flags)
787 {
788 register int s;
789 int i = 0;
790 int toggle, bsearch, bol, eol, exact;
791 UCS *b;
792 UCS prompt[NPMT];
793 UCS *promptp;
794 EXTRAKEYS menu_pat[12];
795
796 bsearch = flags & SR_BACKWRD;
797 bol = flags & SR_BEGLINE;
798 eol = flags & SR_ENDLINE;
799 exact = flags & SR_EXACTSR;
800 toggle = 0; /* reserved for future use */
801
802 memset(&menu_pat, 0, sizeof(menu_pat));
803 /* add exceptions here based on the location of the items in the menu */
804 for(i = 0; i < 10; i++){
805 if(flags & SR_ORIGMEN){
806 menu_pat[i].name = menu_srchpat[10*toggle + i].name;
807 menu_pat[i].label = menu_srchpat[10*toggle + i].label;
808 menu_pat[i].key = menu_srchpat[10*toggle + i].key;
809 if(toggle == 0){
810 if (i == REPLACE_KEY)
811 menu_pat[i].label = repl_mode ? N_("No Replace")
812 : N_("Replace");
813 }
814 } else if(flags & SR_OPTNMEN){
815 menu_pat[i].name = menu_srchopt[i].name;
816 menu_pat[i].label = menu_srchopt[i].label;
817 menu_pat[i].key = menu_srchopt[i].key;
818 switch(i){
819 case EXACTSR_KEY:
820 menu_pat[i].label = exact ? N_("No Exact")
821 : N_("Exact");
822 break;
823 case REPLACE_KEY:
824 menu_pat[i].label = repl_mode ? N_("No Replace")
825 : N_("Replace");
826 break;
827 case BSEARCH_KEY:
828 menu_pat[i].label = bsearch ? N_("Srch Fwd")
829 : N_("Srch Back");
830 break;
831 case BGNLINE_KEY:
832 menu_pat[i].label = bol ? N_("Anywhere")
833 : N_("Bgn Line");
834 break;
835 case ENDLINE_KEY:
836 menu_pat[i].label = eol ? N_("Anywhere")
837 : N_("End Line");
838 break;
839 default : break;
840 }
841 if(menu_pat[i].name)
842 KS_OSDATASET(&menu_pat[i], KS_NONE);
843 }
844 }
845 b = utf8_to_ucs4_cpystr(utf8prompt);
846 if(b){
847 ucs4_strncpy(prompt, b, NPMT);
848 prompt[NPMT-1] = '\0';
849 if(bsearch){
850 fs_give((void **) &b);
851 b = utf8_to_ucs4_cpystr(N_(" backward"));
852 if(b) ucs4_strncat(prompt, b, ucs4_strlen(b));
853 prompt[NPMT-1] = '\0';
854 }
855 if(bol){
856 fs_give((void **) &b);
857 b = utf8_to_ucs4_cpystr(N_(" at start of line"));
858 if(b) ucs4_strncat(prompt, b, ucs4_strlen(b));
859 prompt[NPMT-1] = '\0';
860 } else if(eol){
861 fs_give((void **) &b);
862 b = utf8_to_ucs4_cpystr(N_(" at end of line"));
863 if(b) ucs4_strncat(prompt, b, ucs4_strlen(b));
864 prompt[NPMT-1] = '\0';
865 }
866 if(exact){
867 fs_give((void **) &b);
868 b = utf8_to_ucs4_cpystr(N_(" exactly for"));
869 if(b) ucs4_strncat(prompt, b, ucs4_strlen(b));
870 prompt[NPMT-1] = '\0';
871 }
872 if(b) fs_give((void **) &b);
873 }
874
875 promptp = &prompt[ucs4_strlen(prompt)];
876
877 if(repl_mode){
878 b = utf8_to_ucs4_cpystr(" (to replace)");
879 if(b){
880 ucs4_strncpy(promptp, b, NPMT-(promptp-prompt));
881 promptp += ucs4_strlen(promptp);
882 prompt[NPMT-1] = '\0';
883 fs_give((void **) &b);
884 }
885 }
886
887 if(pat[0] != '\0'){
888 if((promptp-prompt) < NPMT-2){
889 *promptp++ = ' ';
890 *promptp++ = '[';
891 *promptp = '\0';
892 }
893
894 expandp(pat, promptp, NPMT-(promptp-prompt));
895 prompt[NPMT-1] = '\0';
896 promptp += ucs4_strlen(promptp);
897
898 if((promptp-prompt) < NPMT-1){
899 *promptp++ = ']';
900 *promptp = '\0';
901 }
902 }
903
904 if((promptp-prompt) < NPMT-2){
905 *promptp++ = ':';
906 *promptp++ = ' ';
907 *promptp = '\0';
908 }
909
910 prompt[NPMT-1] = '\0';
911
912 s = mlreplyd(prompt, defpat, defpatlen, QDEFLT, menu_pat);
913
914 if (s == TRUE || s == FALSE){ /* changed or not, they're done */
915 if(!defpat[0]){ /* use default */
916 ucs4_strncpy(defpat, pat, defpatlen);
917 defpat[defpatlen-1] = '\0';
918 }
919 else if(ucs4_strcmp(pat, defpat)){ /* Specified */
920 ucs4_strncpy(pat, defpat, NPAT);
921 pat[NPAT-1] = '\0';
922 rpat[0] = '\0';
923 }
924
925 s = TRUE; /* let caller know to proceed */
926 }
927
928 return(s);
929 }
930
931
932 /*
933 * Read a pattern. Stash it in the external variable "pat". The "pat" is not
934 * updated if the user types in an empty line. If the user typed an empty line,
935 * and there is no old pattern, it is an error. Display the old pattern, in the
936 * style of Jeff Lomicka. There is some do-it-yourself control expansion.
937 * change to using <ESC> to delemit the end-of-pattern to allow <NL>s in
938 * the search string.
939 */
940
941 int
942 readnumpat(char *utf8prompt)
943 {
944 int i, n;
945 char numpat[NPMT];
946 EXTRAKEYS menu_pat[12];
947
948 memset(&menu_pat, 0, 10*sizeof(EXTRAKEYS));
949 menu_pat[i = 0].name = "^T";
950 menu_pat[i].label = N_("No Line Number");
951 menu_pat[i].key = (CTRL|'T');
952 KS_OSDATASET(&menu_pat[i++], KS_NONE);
953
954 menu_pat[i].name = NULL;
955
956 numpat[0] = '\0';
957 while(1)
958 switch(mlreplyd_utf8(utf8prompt, numpat, NPMT, QNORML, menu_pat)){
959 case TRUE :
960 if(*numpat){
961 for(i = n = 0; numpat[i]; i++)
962 if(strchr("0123456789", numpat[i])){
963 n = (n * 10) + (numpat[i] - '0');
964 }
965 else
966 return(-2);
967
968 return(n);
969 }
970
971 case FALSE :
972 default :
973 return(-1);
974
975 case (CTRL|'T') :
976 return(-3);
977
978 case (CTRL|'L') :
979 case HELPCH :
980 break;
981 }
982 }
983
984
985 int
986 readpattern(char *utf8prompt, int text_mode, int flags)
987 {
988 register int s;
989 int i;
990 int toggle, bsearch, bol, eol, exact;
991 UCS *b;
992 UCS tpat[NPAT+20];
993 UCS *tpatp;
994 EXTRAKEYS menu_pat[12];
995
996 bsearch = flags & SR_BACKWRD;
997 bol = flags & SR_BEGLINE;
998 eol = flags & SR_ENDLINE;
999 exact = flags & SR_EXACTSR;
1000 toggle = 0; /* reserved for future use */
1001
1002 memset(&menu_pat, 0, sizeof(menu_pat));
1003 /* add exceptions here based on the location of the items in the menu */
1004 for(i = 0; i < 10; i++){
1005 if(flags & SR_ORIGMEN){
1006 menu_pat[i].name = menu_srchpat[10*toggle + i].name;
1007 menu_pat[i].label = menu_srchpat[10*toggle + i].label;
1008 menu_pat[i].key = menu_srchpat[10*toggle + i].key;
1009 if(toggle == 0){
1010 if (i == REPLACE_KEY)
1011 memset(&menu_pat[i], 0, sizeof(EXTRAKEYS));
1012 if (i > REPLACE_KEY && !text_mode)
1013 memset(&menu_pat[i], 0, sizeof(EXTRAKEYS));
1014 }
1015 } else if(flags & SR_OPTNMEN){
1016 menu_pat[i].name = menu_srchopt[i].name;
1017 menu_pat[i].label = menu_srchopt[i].label;
1018 menu_pat[i].key = menu_srchopt[i].key;
1019 switch(i){
1020 case EXACTSR_KEY:
1021 menu_pat[i].label = exact ? N_("No Exact")
1022 : N_("Exact");
1023 break;
1024 case BSEARCH_KEY:
1025 menu_pat[i].label = bsearch ? N_("Srch Fwd")
1026 : N_("Srch Back");
1027 break;
1028 case BGNLINE_KEY:
1029 menu_pat[i].label = bol ? N_("Anywhere")
1030 : N_("Bgn Line");
1031 break;
1032 case ENDLINE_KEY:
1033 menu_pat[i].label = eol ? N_("Anywhere")
1034 : N_("End Line");
1035 break;
1036 default : break;
1037 }
1038 if(menu_pat[i].name)
1039 KS_OSDATASET(&menu_pat[i], KS_NONE);
1040 }
1041 }
1042
1043 b = utf8_to_ucs4_cpystr(utf8prompt);
1044 if(b){
1045 ucs4_strncpy(tpat, b, NPAT+20);
1046 tpat[NPAT+20-1] = '\0';
1047 if(bsearch){
1048 fs_give((void **) &b);
1049 b = utf8_to_ucs4_cpystr(N_(" backward"));
1050 if(b) ucs4_strncat(tpat, b, ucs4_strlen(b));
1051 tpat[NPAT+20-1] = '\0';
1052 }
1053 if(bol){
1054 fs_give((void **) &b);
1055 b = utf8_to_ucs4_cpystr(N_(" at start of line"));
1056 if(b) ucs4_strncat(tpat, b, ucs4_strlen(b));
1057 tpat[NPAT+20-1] = '\0';
1058 } else if (eol){
1059 fs_give((void **) &b);
1060 b = utf8_to_ucs4_cpystr(N_(" at end of line"));
1061 if(b) ucs4_strncat(tpat, b, ucs4_strlen(b));
1062 tpat[NPAT+20-1] = '\0';
1063 }
1064 if (exact){
1065 fs_give((void **) &b);
1066 b = utf8_to_ucs4_cpystr(N_(" exactly for"));
1067 if(b) ucs4_strncat(tpat, b, ucs4_strlen(b));
1068 tpat[NPAT+20-1] = '\0';
1069 }
1070 if(b) fs_give((void **) &b);
1071 }
1072
1073 tpatp = &tpat[ucs4_strlen(tpat)];
1074
1075 if(pat[0] != '\0'){
1076 if((tpatp-tpat) < NPAT+20-2){
1077 *tpatp++ = ' ';
1078 *tpatp++ = '[';
1079 *tpatp = '\0';
1080 }
1081
1082 expandp(pat, tpatp, NPAT+20-(tpatp-tpat));
1083 tpat[NPAT+20-1] = '\0';
1084 tpatp += ucs4_strlen(tpatp);
1085
1086 if((tpatp-tpat) < NPAT+20-1){
1087 *tpatp++ = ']';
1088 *tpatp = '\0';
1089 }
1090 }
1091
1092 if((tpatp-tpat) < NPAT+20-3){
1093 *tpatp++ = ' ';
1094 *tpatp++ = ':';
1095 *tpatp++ = ' ';
1096 *tpatp = '\0';
1097 }
1098
1099 tpat[NPAT+20-1] = '\0';
1100
1101 s = mlreplyd(tpat, tpat, NPAT, QNORML, menu_pat);
1102
1103 if ((s == TRUE) && ucs4_strcmp(pat,tpat)){ /* Specified */
1104 ucs4_strncpy(pat, tpat, NPAT);
1105 pat[NPAT-1] = '\0';
1106 rpat[0] = '\0';
1107 }
1108 else if (s == FALSE && pat[0] != '\0') /* CR, but old one */
1109 s = TRUE;
1110
1111 return(s);
1112 }
1113
1114 /* given a line, reverse its content */
1115 void reverse_line(LINE *l)
1116 {
1117 int i, j, a;
1118 UCS u;
1119
1120 if(l == NULL) return;
1121 j = llength(l) - 1;
1122 for(i = 0; i < j; i++, j--){
1123 u = lgetc(l, j).c; /* reverse the text */
1124 lgetc(l, j).c = lgetc(l, i).c;
1125 lgetc(l, i).c = u;
1126 a = lgetc(l, j).a; /* and the attribute */
1127 lgetc(l, j).a = lgetc(l, i).a;
1128 lgetc(l, i).a = a;
1129 }
1130 }
1131
1132 void
1133 reverse_all(UCS *pat, int bsearch)
1134 {
1135 if(bsearch != 0){
1136 reverse_buffer();
1137 reverse_ucs4(pat);
1138 }
1139 }
1140
1141 void
1142 reverse_buffer(void)
1143 {
1144 LINE *l;
1145
1146 for(l = lforw(curbp->b_linep); l != curbp->b_linep; l = lforw(l))
1147 reverse_line(l);
1148
1149 /* reverse links in buffer */
1150 l = curbp->b_linep;
1151 do {
1152 lforw(l) = lback(l);
1153 l = lforw(l);
1154 } while(l != curbp->b_linep);
1155
1156 l = curbp->b_linep;
1157 do {
1158 lback(lforw(l)) = l;
1159 l = lforw(l);
1160 } while (l != curbp->b_linep);
1161
1162 curwp->w_doto = llength(curwp->w_dotp) - 1 - curwp->w_doto;
1163 }
1164
1165
1166
1167 /* given a UCS4 string reverse its content */
1168 void reverse_ucs4(UCS *s)
1169 {
1170 int i, j;
1171 UCS u;
1172
1173 j = ucs4_strlen(s) - 1;
1174 for(i = 0; i < j; i++, j--){
1175 u = s[j];
1176 s[j] = s[i];
1177 s[i] = u;
1178 }
1179 }
1180
1181
1182 /* search forward for a <patrn>.
1183 * A backward search is a forward search in backward lines with backward
1184 * patterns
1185 */
1186 int
1187 forscan(int *wrapt, /* boolean indicating search wrapped */
1188 UCS *patrn, /* string to scan for */
1189 int flags, /* direction and position */
1190 LINE *limitp, /* stop searching if reached */
1191 int limito, /* stop searching if reached */
1192 int leavep) /* place to leave point
1193 PTBEG = begining of match
1194 PTEND = at end of match */
1195
1196 {
1197 LINE *curline; /* current line during scan */
1198 int curoff; /* position within current line */
1199 LINE *lastline; /* last line position during scan */
1200 int lastoff; /* position within last line */
1201 UCS c; /* character at current position */
1202 LINE *matchline; /* current line during matching */
1203 int matchoff; /* position in matching line */
1204 UCS *patptr; /* pointer into pattern */
1205 int stopoff; /* offset to stop search */
1206 LINE *stopline; /* line to stop search */
1207 int ftest; /* position of first character of test */
1208 int bsearch;
1209 int bol;
1210 int eol;
1211
1212 bsearch = flags & SR_BACKWRD;
1213 bol = flags & SR_BEGLINE;
1214 eol = flags & SR_ENDLINE;
1215 *wrapt = FALSE;
1216
1217 /* if bsearch is set we return the match at the beginning of the
1218 * matching string, so we make this algorithm return the end of
1219 * the string, so that when we reverse we be at the beginning.
1220 */
1221 if(bsearch)
1222 leavep = leavep == PTBEG ? PTEND : PTBEG;
1223
1224 /*
1225 * the idea is to set the character to end the search at the
1226 * next character in the buffer. thus, let the search wrap
1227 * completely around the buffer.
1228 *
1229 * first, test to see if we are at the end of the line,
1230 * otherwise start searching on the next character.
1231 */
1232 if(curwp->w_doto == llength(curwp->w_dotp)){
1233 /*
1234 * dot is not on end of a line
1235 * start at 0 offset of the next line
1236 */
1237 stopoff = curoff = 0;
1238 stopline = curline = lforw(curwp->w_dotp);
1239 if (curwp->w_dotp == curbp->b_linep)
1240 *wrapt = TRUE;
1241 }
1242 else{
1243 stopoff = curoff = curwp->w_doto;
1244 stopline = curline = curwp->w_dotp;
1245 }
1246
1247 /* scan each character until we hit the head link record */
1248
1249 /*
1250 * maybe wrapping is a good idea
1251 */
1252 while (curline){
1253
1254 if(curline == curbp->b_linep)
1255 *wrapt = TRUE;
1256
1257 /* save the current position in case we need to
1258 restore it on a match */
1259
1260 lastline = curline;
1261 lastoff = curoff;
1262
1263 /* get the current character resolving EOLs */
1264 if (curoff == llength(curline)) { /* if at EOL */
1265 curline = lforw(curline); /* skip to next line */
1266 curoff = 0;
1267 c = '\n'; /* and return a <NL> */
1268 }
1269 else if(curoff == -1){
1270 stopoff = curoff = 0;
1271 continue;
1272 c = '\n';
1273 }
1274 else
1275 c = lgetc(curline, curoff++).c; /* get the char */
1276
1277 if(bol)
1278 ftest = bsearch == 0 ? 1 : llength(curline) - ucs4_strlen(patrn) + 1;
1279 else if (eol)
1280 ftest = bsearch == 0 ? llength(curline) - ucs4_strlen(patrn) + 1 : 1;
1281 /* test it against first char in pattern */
1282 if (eq(c, patrn[0]) != FALSE /* if we find it..*/
1283 && ((bol == 0 && eol == 0) /* ...and if it is anywhere */
1284 || (bol != 0 /* ...or is at the begin or line */
1285 && ((bsearch == 0 && curoff == ftest) /* and search forward and found at beginning of line */
1286 || (bsearch != 0 && curoff == ftest))) /* or search backward and found at end of line */
1287 || (eol != 0 /* ...or is at the end or line */
1288 && ((bsearch == 0 && curoff == ftest) /* and search forward and found at beginning of line */
1289 || (bsearch != 0 && curoff == ftest))) /* or search backward and found at end of line */
1290 )){
1291 /* setup match pointers */
1292 matchline = curline;
1293 matchoff = curoff;
1294 patptr = &patrn[0];
1295
1296 /* scan through patrn for a match */
1297 while (*++patptr != '\0') {
1298 /* advance all the pointers */
1299 if (matchoff >= llength(matchline)) {
1300 /* advance past EOL */
1301 matchline = lforw(matchline);
1302 matchoff = 0;
1303 c = '\n';
1304 } else
1305 c = lgetc(matchline, matchoff++).c;
1306
1307 if(matchline == limitp && matchoff == limito)
1308 return(FALSE);
1309
1310 /* and test it against the pattern */
1311 if (eq(*patptr, c) == FALSE)
1312 goto fail;
1313 }
1314
1315 /* A SUCCESSFULL MATCH!!! */
1316 /* reset the global "." pointers */
1317 if (leavep == PTEND) { /* at end of string */
1318 curwp->w_dotp = matchline;
1319 curwp->w_doto = matchoff - 1;
1320 }
1321 else { /* at begining of string */
1322 curwp->w_dotp = lastline;
1323 curwp->w_doto = lastoff;
1324 }
1325
1326 curwp->w_flag |= WFMOVE; /* flag that we have moved */
1327 return(TRUE);
1328 }
1329
1330 fail:; /* continue to search */
1331 if(((curline == stopline) && (curoff == stopoff))
1332 || (curline == limitp && curoff == limito))
1333 break; /* searched everywhere... */
1334 }
1335 /* we could not find a match */
1336
1337 return(FALSE);
1338 }
1339
1340
1341
1342 /* expandp: expand control key sequences for output */
1343 int
1344 expandp(UCS *srcstr, /* string to expand */
1345 UCS *deststr, /* destination of expanded string */
1346 int maxlength) /* maximum chars in destination */
1347 {
1348 UCS c; /* current char to translate */
1349
1350 /* scan through the string */
1351 while ((c = *srcstr++) != 0) {
1352 if (c == '\n') { /* its an EOL */
1353 *deststr++ = '<';
1354 *deststr++ = 'N';
1355 *deststr++ = 'L';
1356 *deststr++ = '>';
1357 maxlength -= 4;
1358 } else if (c < 0x20 || c == 0x7f) { /* control character */
1359 *deststr++ = '^';
1360 *deststr++ = c ^ 0x40;
1361 maxlength -= 2;
1362 } else if (c == '%') {
1363 *deststr++ = '%';
1364 *deststr++ = '%';
1365 maxlength -= 2;
1366 } else { /* any other character */
1367 *deststr++ = c;
1368 maxlength--;
1369 }
1370
1371 /* check for maxlength */
1372 if (maxlength < 4) {
1373 *deststr++ = '$';
1374 *deststr = '\0';
1375 return(FALSE);
1376 }
1377 }
1378
1379 *deststr = '\0';
1380 return(TRUE);
1381 }
1382
1383
1384 /*
1385 * chword() - change the given word, wp, pointed to by the curwp->w_dot
1386 * pointers to the word in cb
1387 * if bsearch is set, then cb is supposed to come unreversed, while
1388 * the buffer is supposed to be reversed, so we must reverse cb before
1389 * inserting it.
1390 */
1391 void
1392 chword(UCS *wb, UCS *cb, int bsearch)
1393 {
1394 UCS *u;
1395 ldelete(ucs4_strlen(wb), NULL); /* not saved in kill buffer */
1396 if(bsearch) reverse_ucs4(cb);
1397 for(u = cb; *u != '\0'; u++)
1398 linsert(1, *u);
1399 if(bsearch) reverse_ucs4(cb);
1400
1401 curwp->w_flag |= WFEDIT;
1402 }
1403
1404 void
1405 supdate(UCS *pat, int bsearch)
1406 {
1407 reverse_all(pat, bsearch); /* undo reverse buffer and pattern */
1408 update();
1409 reverse_all(pat, bsearch); /* reverse buffer and pattern */
1410 }
1411
1412 char *
1413 sucs4_to_utf8_cpystr(UCS *orig, int bsearch)
1414 {
1415 char *utf8;
1416 if(bsearch) reverse_ucs4(orig);
1417 utf8 = ucs4_to_utf8_cpystr(orig);
1418 if(bsearch) reverse_ucs4(orig);
1419 return utf8;
1420 }
Alpine is a program to manage e-mail