![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to search.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / me|
Return to search.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / me |
1.1 root 1:
2: /*
3: * The functions in this file implement the search commands (both plain
4: * and incremental searches are supported) and the query-replace command.
5: *
6: * The plain old search code is part of the original MicroEMACS "distribution".
7: * The incremental search code, and the query-replace code, is by Rich Ellison,
8: * with some stylistic modifications.
9: */
10: #include <stdio.h>
11: #include "ed.h"
12:
13: #define CCHR(x) ((x)-'@')
14:
15: #define SRCH_BEGIN (0) /* Search sub-codes. */
16: #define SRCH_FORW (-1)
17: #define SRCH_BACK (-2)
18: #define SRCH_PREV (-3)
19: #define SRCH_NEXT (-4)
20: #define SRCH_NOPR (-5)
21: #define SRCH_ACCM (-6)
22:
23: typedef struct {
24: int s_code;
25: LINE *s_dotp;
26: int s_doto;
27: } SRCHCOM;
28:
29: extern int ctrlg();
30:
31: static SRCHCOM cmds[NSRCH];
32: static int cip;
33:
34: int srch_lastdir = SRCH_NOPR; /* Last search flags. */
35:
36: /*
37: * Search forward.
38: * Get a search string from the user, and search for it, starting at ".".
39: * If found, "." gets moved to just after the matched characters, and display
40: * does all the hard stuff. If not found, it just prints a message.
41: * This is normally bound to "M-S".
42: */
43: forwsearch(f, n)
44: {
45: register int s;
46:
47: if ((s=readpattern("Search")) != TRUE)
48: return (s);
49: if (forwsrch() == FALSE) {
50: mlwrite("Not found");
51: return (FALSE);
52: }
53: srch_lastdir = SRCH_FORW;
54: return (TRUE);
55: }
56:
57: /*
58: * Reverse search.
59: * Get a search string from the user, and search, starting at "."
60: * and proceeding toward the front of the buffer. If found "." is left
61: * pointing at the first character of the pattern [the last character that
62: * was matched]. Bound to "M-R".
63: */
64: backsearch(f, n)
65: {
66: register int s;
67:
68: if ((s=readpattern("Reverse search")) != TRUE)
69: return (s);
70: if (backsrch() == FALSE) {
71: mlwrite("Not found");
72: return (FALSE);
73: }
74: srch_lastdir = SRCH_BACK;
75: return (TRUE);
76: }
77:
78: /*
79: * Search again, using the same search string and direction as the last search
80: * command. The direction has been saved in "srch_lastdir", so you know which
81: * way to go.
82: * Bound to "M-/".
83: */
84: searchagain(f, n)
85: {
86: if (srch_lastdir == SRCH_FORW) {
87: if (forwsrch() == FALSE) {
88: mlwrite("Not found");
89: return (FALSE);
90: }
91: return (TRUE);
92: }
93: if (srch_lastdir == SRCH_BACK) {
94: if (backsrch() == FALSE) {
95: mlwrite("Not found");
96: return (FALSE);
97: }
98: return (TRUE);
99: }
100: mlwrite("No last search");
101: return (FALSE);
102: }
103:
104: /*
105: * Use incremental searching, initially in the forward direction.
106: * isearch ignores any explicit arguments.
107: */
108: forwisearch(f, n)
109: {
110: return (isearch(SRCH_FORW));
111: }
112:
113: /*
114: * Use incremental searching, initially in the reverse direction.
115: * isearch ignores any explicit arguments.
116: */
117: backisearch(f, n)
118: {
119: return (isearch(SRCH_BACK));
120: }
121:
122: /*
123: * Incremental Search.
124: * dir is used as the initial direction to search.
125: * ^N find next occurance (if first thing typed reuse old string).
126: * ^P find prev occurance (if first thing typed reuse old string).
127: * ^S switch direction to forward, find next
128: * ^R switch direction to reverse, find prev
129: * ^Q quote next character (allows searching for ^N etc.)
130: * <ESC> exit from Isearch.
131: * <DEL>
132: * ^H undoes last character typed. (tricky job to do this correctly).
133: * else accumulate into search string
134: */
135: isearch(dir)
136: {
137: int c;
138: int pptr;
139: LINE *clp;
140: int cbo;
141: int success;
142:
143: for (cip=0; cip<NSRCH; cip++)
144: cmds[cip].s_code = SRCH_NOPR;
145: cip = 0;
146: pptr = -1;
147: clp = curwp->w_dotp;
148: cbo = curwp->w_doto;
149: isrch_lpush();
150: isrch_cpush(SRCH_BEGIN);
151: success = TRUE;
152: isrch_prompt(dir,TRUE,success);
153: for (;;) {
154: update();
155: c = ttgetc();
156: bracketoff();
157: switch (c) {
158:
159: case CCHR('M'):
160: case METACH:
161: #if LK201
162: case AGRAVE:
163: #endif
164: srch_lastdir = dir;
165: mlwrite("[Done]");
166: return (TRUE);
167:
168: case CCHR('G'):
169: curwp->w_dotp = clp;
170: curwp->w_doto = cbo;
171: curwp->w_flag |= WFMOVE;
172: srch_lastdir = dir;
173: mlwrite("Aborting");
174: return (FALSE);
175:
176: case CCHR('S'):
177: case CCHR('F'):
178: if (dir == SRCH_BACK) {
179: dir = SRCH_FORW;
180: isrch_lpush();
181: isrch_cpush(SRCH_FORW);
182: success = TRUE;
183: }
184: /* drop through to find next */
185:
186: case CCHR('N'):
187: if ((success == FALSE)&&(dir == SRCH_FORW))
188: break;
189: isrch_lpush();
190: forwchar(FALSE, 1);
191: if (isrch_find(SRCH_NEXT) != FALSE) {
192: isrch_cpush(SRCH_NEXT);
193: pptr = strlen(pat);
194: } else {
195: backchar(FALSE, 1);
196: tbeep();
197: success = FALSE;
198: }
199: isrch_prompt(dir,FALSE,success);
200: break;
201:
202: case CCHR('R'):
203: case CCHR('B'):
204: if (dir == SRCH_FORW) {
205: dir = SRCH_BACK;
206: isrch_lpush();
207: isrch_cpush(SRCH_BACK);
208: success = TRUE;
209: }
210: /* drop through to find prev */
211:
212: case CCHR('P'):
213: if ((success == FALSE)&&(dir == SRCH_BACK))
214: break;
215: isrch_lpush();
216: backchar(FALSE, 1);
217: if (isrch_find(SRCH_PREV) != FALSE) {
218: isrch_cpush(SRCH_PREV);
219: pptr = strlen(pat);
220: } else {
221: forwchar(FALSE, 1);
222: tbeep();
223: success = FALSE;
224: }
225: isrch_prompt(dir,FALSE,success);
226: break;
227:
228: case CCHR('H'):
229: case 0x7f:
230: if (isrch_undo(&pptr,&dir) != TRUE) {
231: return (ABORT);
232: }
233: if (isrch_peek() != SRCH_ACCM)
234: success = TRUE;
235: isrch_prompt(dir,FALSE,success);
236: break;
237:
238: case CCHR('^'):
239: case CCHR('Q'):
240: c = ttgetc();
241: case CCHR('U'):
242: case CCHR('X'):
243: case CCHR('I'):
244: case CCHR('J'):
245: goto addchar;
246: default:
247: if (c < ' ') { /* uninterpreted ctrl */
248: c += '@';
249: c |= CTRL;
250: success = execute(c, FALSE, 1);
251: curwp->w_flag |= WFMOVE;
252: return (success);
253: }
254: addchar:
255: if (pptr == -1)
256: pptr=0;
257: if (pptr == 0)
258: success = TRUE;
259: pat[pptr++] = c;
260: if (pptr==NPAT) {
261: mlwrite("Pattern too long");
262: ctrlg(FALSE, 0);
263: return (ABORT);
264: }
265: pat[pptr] = '\0';
266: isrch_lpush();
267: if (success != FALSE) {
268: if (isrch_find(dir) != FALSE) {
269: isrch_cpush(c);
270: } else {
271: success = FALSE;
272: tbeep();
273: isrch_cpush(SRCH_ACCM);
274: }
275: } else {
276: isrch_cpush(SRCH_ACCM);
277: }
278: isrch_prompt(dir, FALSE, success);
279: }
280: }
281: }
282:
283: isrch_cpush(cmd)
284: register int cmd;
285: {
286: if (++cip >= NSRCH)
287: cip = 0;
288: cmds[cip].s_code = cmd;
289: }
290:
291: isrch_lpush()
292: {
293: register int ctp;
294:
295: ctp = cip+1;
296: if (ctp >= NSRCH)
297: ctp = 0;
298: cmds[ctp].s_code = SRCH_NOPR;
299: cmds[ctp].s_doto = curwp->w_doto;
300: cmds[ctp].s_dotp = curwp->w_dotp;
301: }
302:
303: isrch_pop()
304: {
305: if (cmds[cip].s_code != SRCH_NOPR) {
306: curwp->w_doto = cmds[cip].s_doto;
307: curwp->w_dotp = cmds[cip].s_dotp;
308: curwp->w_flag |= WFMOVE; /* Was "=", wrong. */
309: cmds[cip].s_code = SRCH_NOPR;
310: }
311: if (--cip <= 0) /* Is "=" right? */
312: cip = NSRCH-1;
313: }
314:
315: int
316: isrch_peek()
317: {
318: if (cip == 0)
319: return (cmds[NSRCH-1].s_code);
320: else
321: return (cmds[cip-1].s_code);
322: }
323:
324: int
325: isrch_undo(pptr,dir)
326: register int *pptr;
327: register int *dir;
328: {
329: switch (cmds[cip].s_code) {
330: case SRCH_NOPR:
331: case SRCH_BEGIN:
332: case SRCH_NEXT:
333: case SRCH_PREV:
334: break;
335:
336: case SRCH_FORW:
337: if (*dir == SRCH_BACK) {
338: mlwrite("ISEARCH error, to back when already back");
339: return (FALSE);
340: }
341: *dir = SRCH_BACK;
342: break;
343:
344: case SRCH_BACK:
345: if (*dir == SRCH_FORW) {
346: mlwrite("ISEARCH error, to forw when already forw");
347: return (FALSE);
348: }
349: *dir = SRCH_FORW;
350: break;
351:
352: case SRCH_ACCM:
353: default:
354: if (*pptr == 0) {
355: mlwrite("ISEARCH error, delete without character");
356: return (FALSE);
357: }
358: *pptr -= 1;
359: if (*pptr < 0)
360: *pptr = 0;
361: pat[*pptr] = '\0';
362: break;
363: }
364: isrch_pop();
365: return (TRUE);
366: }
367:
368: isrch_find(dir)
369: register int dir;
370: {
371: register int plen;
372:
373: plen = strlen(pat);
374: if (plen != 0) {
375: if (dir==SRCH_FORW || dir==SRCH_NEXT) {
376: backchar(FALSE, plen);
377: if (forwsrch() == FALSE) {
378: forwchar(FALSE, plen);
379: return (FALSE);
380: }
381: return (TRUE);
382: }
383: if (dir==SRCH_BACK || dir==SRCH_PREV) {
384: forwchar(FALSE, plen);
385: if (backsrch() == FALSE) {
386: backchar(FALSE, plen);
387: return (FALSE);
388: }
389: return (TRUE);
390: }
391: mlwrite("bad call to isrch_find");
392: ctrlg(FALSE, 0);
393: return (FALSE);
394: }
395: return (FALSE);
396: }
397:
398: /*
399: * If called with "dir" not one of SRCH_FORW
400: * or SRCH_BACK, this routine used to print an error
401: * message. It also used to return TRUE or FALSE,
402: * depending on if it liked the "dir". However, none
403: * of the callers looked at the status, so I just
404: * made the checking vanish.
405: */
406: isrch_prompt(dir, flag, success)
407: {
408: if (dir == SRCH_FORW) {
409: if (success != FALSE)
410: isrch_dspl("i-search forward", flag);
411: else {
412: isrch_dspl("failing i-search forward", flag);
413: curwp->w_flag |= WFEDIT;
414: }
415:
416: } else if (dir == SRCH_BACK) {
417: if (success != FALSE)
418: isrch_dspl("i-search backward", flag);
419: else {
420: isrch_dspl("failing i-search backward", flag);
421: curwp->w_flag |= WFEDIT;
422: }
423: }
424: }
425:
426: /*
427: * Prompt writing routine for the incremental
428: * search. The "prompt" is just a string. The "flag" determines
429: * if a "[ ]" or ":" embelishment is used. The string is packed
430: * into a big buffer and zapped out with a single call to
431: * "mlwrite". The "26" in the "tpat" declaration is the length
432: * of the longest prompt string. This actually isn't long
433: * enough if the pattern is full of control characters
434: * and other things that need an "^".
435: */
436: isrch_dspl(prompt, flag)
437: uchar *prompt;
438: {
439: register uchar *cp1;
440: register uchar *cp2;
441: register unsigned c;
442: uchar tpat[NPAT+26+2+1+1];
443:
444: cp1 = &tpat[0];
445: cp2 = prompt;
446: while ((c = *cp2++) != '\0')
447: *cp1++ = c;
448: if (flag != FALSE) {
449: *cp1++ = ' ';
450: *cp1++ = '[';
451: } else {
452: *cp1++ = ':';
453: *cp1++ = ' ';
454: }
455: cp2 = &pat[0];
456: while ((c = *cp2++) != 0) {
457: if (cp1 < &tpat[NPAT+20-4]) { /* "??]\0" */
458: if (dblchr(c)) {
459: *cp1++ = '^';
460: c ^= 0x40;
461: } else if (c == '%') /* Map "%" to */
462: *cp1++ = c; /* "%%". */
463: *cp1++ = c;
464: }
465: }
466: if (flag != FALSE)
467: *cp1++ = ']';
468: *cp1= '\0';
469: mlwrite(tpat);
470: }
471:
472: /*
473: * Query Replace.
474: * Replace strings selectively. Does a search and replace operation.
475: * A space or a comma replaces the string, a period replaces and quits,
476: * an n doesn't replace, a C-G quits.
477: */
478: queryrepl(f, n)
479: {
480: register int s;
481: uchar news[NPAT];
482: LINE *clp;
483: int cbo;
484: register int flg;
485: register int flgc;
486: int rcnt;
487:
488: if ((s=readpattern("Old string")) != TRUE)
489: return (s);
490: if ((s=mlreply("New string: ",news, NPAT)) == ABORT)
491: return (s);
492: if (s == FALSE) /* Null string. */
493: news[0] = '\0';
494: mlwrite("Query Replace: [%s] -> [%s]", pat, news);
495: clp = curwp->w_dotp;
496: cbo = curwp->w_doto;
497: rcnt = 0;
498: flg = TRUE;
499: flgc = FALSE;
500: while (flg==TRUE && forwsrch()==TRUE) {
501: if (flgc != TRUE) {
502: retry:
503: update();
504: switch (ttgetc()) {
505: case ' ':
506: case ',':
507: replstring(news, f);
508: rcnt++;
509: break;
510:
511: case '.':
512: replstring(news, f);
513: rcnt++;
514: flg = FALSE;
515: break;
516:
517: case '\007':
518: flg = ABORT;
519: ctrlg(FALSE, 0);
520: break;
521:
522: case '!':
523: replstring(news, f);
524: rcnt++;
525: flgc = TRUE;
526: break;
527:
528: case 'n':
529: break;
530:
531: default:
532: mlwrite("<SP>[,] replace, [.] rep-end, [n] dont, [!] repl rest <C-G> quit");
533: goto retry;
534: }
535: } else {
536: replstring(news, f);
537: rcnt++;
538: }
539: }
540: curwp->w_dotp = clp;
541: curwp->w_doto = cbo;
542: curwp->w_flag |= WFHARD;
543: update();
544: if (rcnt == 0)
545: mlwrite("[No replacements done]");
546: else if (rcnt == 1)
547: mlwrite("[1 replacement done]");
548: else
549: mlwrite("[%d replacements done]", rcnt);
550: return (TRUE);
551: }
552:
553: #define FLOWER 0 /* Found lower case. */
554: #define FCAPTL 1 /* Found capital. */
555: #define FUPPER 2 /* Found upper case. */
556:
557: replstring(st, f)
558: uchar *st;
559: int f;
560: {
561: register uchar *tpt;
562: register int plen;
563: register int rtype;
564: register int c, d;
565:
566: plen = strlen(pat);
567: backchar(TRUE, plen);
568: c = lgetc(curwp->w_dotp, curwp->w_doto);
569: rtype = FLOWER;
570: if (ishi(c)) {
571: rtype = FCAPTL;
572: if (curwp->w_doto+1 != llength(curwp->w_dotp)) {
573: c = lgetc(curwp->w_dotp, curwp->w_doto+1);
574: if (ishi(c))
575: rtype = FUPPER;
576: }
577: }
578: ldelete(plen, FALSE);
579: tpt = &st[0];
580: if (f != FALSE) {
581: while (*tpt != '\0')
582: linsert(1, *tpt++);
583: } else {
584: switch (rtype) {
585: case FLOWER:
586: while (*tpt != '\0') {
587: linsert(1, *tpt++);
588: }
589: break;
590:
591: case FCAPTL:
592: if (*tpt != '\0') {
593: if (d = islow(*tpt))
594: linsert(1, d);
595: else
596: linsert(1, *tpt);
597: tpt++;
598: }
599: while (*tpt != '\0')
600: linsert(1, *tpt++);
601: break;
602:
603: case FUPPER:
604: while (*tpt != '\0') {
605: if (d = islow(*tpt))
606: linsert(1, d);
607: else
608: linsert(1, *tpt);
609: tpt++;
610: }
611: break;
612: }
613: }
614: curwp->w_flag |= WFHARD;
615: }
616:
617: /*
618: * This routine does the real work of a
619: * forward search. The pattern is sitting in the external
620: * variable "pat". If found, dot is updated, the window system
621: * is notified of the change, and TRUE is returned. If the
622: * string isn't found, FALSE is returned.
623: */
624: forwsrch()
625: {
626: register LINE *clp;
627: register int cbo;
628: register LINE *tlp;
629: register int tbo;
630: register uchar *pp;
631: register int c;
632:
633: clp = curwp->w_dotp;
634: cbo = curwp->w_doto;
635: while (clp != curbp->b_linep) {
636: if (cbo == llength(clp)) {
637: clp = lforw(clp);
638: cbo = 0;
639: c = '\n';
640: } else
641: c = lgetc(clp, cbo++);
642: if (eq(c, pat[0]) != FALSE) {
643: tlp = clp;
644: tbo = cbo;
645: pp = &pat[1];
646: while (*pp != 0) {
647: if (tlp == curbp->b_linep)
648: goto fail;
649: if (tbo == llength(tlp)) {
650: tlp = lforw(tlp);
651: tbo = 0;
652: c = '\n';
653: } else
654: c = lgetc(tlp, tbo++);
655: if (eq(c, *pp++) == FALSE)
656: goto fail;
657: }
658: curwp->w_dotp = tlp;
659: curwp->w_doto = tbo;
660: curwp->w_flag |= WFMOVE;
661: return (TRUE);
662: }
663: fail: ;
664: }
665: return (FALSE);
666: }
667:
668: /*
669: * This routine does the real work of a
670: * backward search. The pattern is sitting in the external
671: * variable "pat". If found, dot is updated, the window system
672: * is notified of the change, and TRUE is returned. If the
673: * string isn't found, FALSE is returned.
674: */
675: backsrch()
676: {
677: register LINE *clp;
678: register int cbo;
679: register LINE *tlp;
680: register int tbo;
681: register int c;
682: register uchar *epp;
683: register uchar *pp;
684:
685: for (epp = &pat[0]; epp[1] != 0; ++epp)
686: ;
687: clp = curwp->w_dotp;
688: cbo = curwp->w_doto;
689: for (;;) {
690: if (cbo == 0) {
691: clp = lback(clp);
692: if (clp == curbp->b_linep)
693: return (FALSE);
694: cbo = llength(clp)+1;
695: }
696: if (--(cbo) == llength(clp))
697: c = '\n';
698: else
699: c = lgetc(clp,cbo);
700: if (eq(c, *epp) != FALSE) {
701: tlp = clp;
702: tbo = cbo;
703: pp = epp;
704: while (pp != &pat[0]) {
705: if (tbo == 0) {
706: tlp = lback(tlp);
707: if (tlp == curbp->b_linep)
708: goto fail;
709: tbo = llength(tlp)+1;
710: }
711: if (--(tbo) == llength(tlp))
712: c = '\n';
713: else
714: c = lgetc(tlp,tbo);
715: if (eq(c, *--pp) == FALSE)
716: goto fail;
717: }
718: curwp->w_dotp = tlp;
719: curwp->w_doto = tbo;
720: curwp->w_flag |= WFMOVE;
721: return (TRUE);
722: }
723: fail: ;
724: }
725: }
726:
727: /*
728: * Compare two characters.
729: * The "bc" comes from the buffer.
730: * It has it's case folded out. The
731: * "pc" is from the pattern.
732: */
733: eq(bc, pc)
734: register int bc;
735: register int pc;
736: {
737: int c;
738:
739: if (bind.ffold) {
740: if (c = islow(bc))
741: bc = c;
742: if (c = islow(pc))
743: pc = c;
744: }
745: if (bc == pc)
746: return (TRUE);
747: return (FALSE);
748: }
749:
750: /*
751: * Read a pattern.
752: * Stash it in the external variable "pat". The "pat" is
753: * not updated if the user types in an empty line. If the user typed
754: * an empty line, and there is no old pattern, it is an error.
755: * Display the old pattern, in the style of Jeff Lomicka. There is
756: * some do-it-yourself control expansion.
757: */
758: readpattern(prompt)
759: uchar *prompt;
760: {
761: register uchar *cp1;
762: register uchar *cp2;
763: register unsigned c;
764: register int s;
765: uchar tpat[NPAT+20];
766:
767: cp1 = &tpat[0]; /* Copy prompt */
768: cp2 = prompt;
769: while ((c = *cp2++) != '\0')
770: *cp1++ = c;
771: if (pat[0] != '\0') { /* Old pattern */
772: *cp1++ = ' ';
773: *cp1++ = '[';
774: cp2 = &pat[0];
775: while ((c = *cp2++) != 0) {
776: if (cp1 < &tpat[NPAT+20-6]) { /* "??]: \0" */
777: if (dblchr(c)) {
778: *cp1++ = '^';
779: c ^= 0x40;
780: } else if (c == '%') /* Map "%" to */
781: *cp1++ = c; /* "%%". */
782: *cp1++ = c;
783: }
784: }
785: *cp1++ = ']';
786: }
787: *cp1++ = ':'; /* Finish prompt */
788: *cp1++ = ' ';
789: *cp1++ = '\0';
790: s = mlreply(tpat, tpat, NPAT); /* Read pattern */
791: if (s == TRUE) /* Specified */
792: strcpy(pat, tpat);
793: else if (s==FALSE && pat[0]!=0) /* CR, but old one */
794: s = TRUE;
795: return (s);
796: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.