![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to re.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove|
Return to re.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / contrib / jove |
1.1 root 1: /***************************************************************************
2: * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE *
3: * is provided to you without charge, and with no warranty. You may give *
4: * away copies of JOVE, including sources, provided that this notice is *
5: * included in all the files. *
6: ***************************************************************************/
7:
8: /* search package */
9:
10: #include "jove.h"
11: #include "re.h"
12: #include "ctype.h"
13:
14: private char *insert proto((char *, char *, int));
15:
16: private void
17: REreset proto((void)),
18: search proto((int, int, int));
19: private int
20: backref proto((int, char *)),
21: do_comp proto((struct RE_block *,int)),
22: member proto((char *, int, int)),
23: REgetc proto((void)),
24: REmatch proto((char *, char *));
25:
26: char searchstr[128], /* global search string */
27: rep_search[128], /* replace search string */
28: rep_str[128]; /* contains replacement string */
29:
30: int REdirection; /* current direction we're searching in */
31:
32: int CaseIgnore = 0, /* ignore case? */
33: WrapScan = 0, /* wrap at end of buffer? */
34: UseRE = 0; /* use regular expressions */
35:
36: #define cind_cmp(a, b) (CaseEquiv[a] == CaseEquiv[b])
37:
38: private int REpeekc;
39: private char *REptr;
40:
41: private int
42: REgetc()
43: {
44: int c;
45:
46: if ((c = REpeekc) != -1)
47: REpeekc = -1;
48: else if (*REptr)
49: c = *REptr++;
50: else
51: c = 0;
52:
53: return c;
54: }
55:
56: #define STAR 01 /* Match any number of last RE. */
57: #define AT_BOL 2 /* ^ */
58: #define AT_EOL 4 /* $ */
59: #define AT_BOW 6 /* \< */
60: #define AT_EOW 8 /* \> */
61: #define OPENP 10 /* \( */
62: #define CLOSEP 12 /* \) */
63: #define CURLYB 14 /* \{ */
64:
65: #define NOSTR 14 /* Codes <= NOSTR can't be *'d. */
66:
67: #define ANYC (NOSTR+2) /* . */
68: #define NORMC (ANYC+2) /* normal character */
69: #define CINDC (NORMC+2) /* case independent character */
70: #define ONE_OF (CINDC+2) /* [xxx] */
71: #define NONE_OF (ONE_OF+2) /* [^xxx] */
72: #define BACKREF (NONE_OF+2) /* \# */
73: #define EOP (BACKREF+2) /* end of pattern */
74:
75: /* ONE_OF/NONE_OF is represented as a bit vector.
76: * These symbols parameterize the representation.
77: */
78:
79: #define BYTESIZE 8
80: #define SETSIZE (NCHARS / BYTESIZE)
81: #define SETBYTE(c) ((c) / BYTESIZE)
82: #define SETBIT(c) (1 << ((c) % BYTESIZE))
83:
84: #define NPAR 10 /* [0-9] - 0th is the entire matched string, i.e. & */
85: private char *comp_ptr,
86: **alt_p,
87: **alt_endp;
88:
89: void
90: REcompile(pattern, re, re_blk)
91: char *pattern;
92: int re;
93: struct RE_block *re_blk;
94: {
95: REptr = pattern;
96: REpeekc = -1;
97: comp_ptr = re_blk->r_compbuf;
98: alt_p = re_blk->r_alternates;
99: alt_endp = alt_p + NALTS;
100: *alt_p++ = comp_ptr;
101: re_blk->r_nparens = 0;
102: (void) do_comp(re_blk, re ? OKAY_RE : NORM);
103: *alt_p = NULL;
104:
105: re_blk->r_anchored = NO;
106: re_blk->r_firstc = '\0';
107: /* do a little post processing */
108: if (re_blk->r_alternates[1] == NULL) {
109: char *p;
110:
111: p = re_blk->r_alternates[0];
112: for (;;) {
113: switch (*p) {
114: case OPENP:
115: case CLOSEP:
116: p += 2;
117: continue;
118:
119: case AT_BOW:
120: case AT_EOW:
121: p += 1;
122: continue;
123:
124: case AT_BOL:
125: re_blk->r_anchored = YES;
126: /* don't set firstc -- won't work */
127: break;
128:
129: case NORMC:
130: case CINDC:
131: re_blk->r_firstc = CaseEquiv[p[2]];
132: break;
133:
134: default:
135: break;
136: }
137: break;
138: }
139: }
140: }
141:
142: /* compile the pattern into an internal code */
143:
144: private int
145: do_comp(re_blk, kind)
146: struct RE_block *re_blk;
147: int kind;
148: {
149: char *this_verb,
150: *prev_verb,
151: *start_p,
152: *comp_endp;
153: int parens[NPAR],
154: *parenp,
155: c,
156: ret_code;
157:
158: parenp = parens;
159: this_verb = NULL;
160: ret_code = 1;
161: comp_endp = &re_blk->r_compbuf[COMPSIZE - 6];
162:
163: /* wrap the whole expression around (implied) parens */
164: if (kind == OKAY_RE) {
165: *comp_ptr++ = OPENP;
166: *comp_ptr++ = re_blk->r_nparens;
167: *parenp++ = re_blk->r_nparens++;
168: }
169:
170: start_p = comp_ptr;
171:
172: while ((c = REgetc()) != '\0') {
173: if (comp_ptr > comp_endp)
174: toolong: complain("Search string too long/complex.");
175: prev_verb = this_verb;
176: this_verb = comp_ptr;
177:
178: if (kind == NORM && strchr(".[*", c) != 0)
179: goto defchar;
180: switch (c) {
181: case '\\':
182: switch (c = REgetc()) {
183: case 0:
184: complain("[Premature end of pattern]");
185: /*NOTREACHED*/
186:
187: case '{':
188: {
189: char *wcntp; /* word count */
190:
191: *comp_ptr++ = CURLYB;
192: wcntp = comp_ptr;
193: *comp_ptr++ = 0;
194: for (;;) {
195: int comp_val;
196: char *comp_len;
197:
198: comp_len = comp_ptr++;
199: comp_val = do_comp(re_blk, IN_CB);
200: *comp_len = comp_ptr - comp_len;
201: (*wcntp) += 1;
202: if (comp_val == 0)
203: break;
204: }
205: break;
206: }
207:
208: case '}':
209: if (kind != IN_CB)
210: complain("Unexpected \\}.");
211: ret_code = 0;
212: goto outahere;
213:
214: case '(':
215: if (re_blk->r_nparens >= NPAR)
216: complain("Too many ('s; max is %d.", NPAR);
217: *comp_ptr++ = OPENP;
218: *comp_ptr++ = re_blk->r_nparens;
219: *parenp++ = re_blk->r_nparens++;
220: break;
221:
222: case ')':
223: if (parenp == parens)
224: complain("Too many )'s.");
225: *comp_ptr++ = CLOSEP;
226: *comp_ptr++ = *--parenp;
227: break;
228:
229: case '|':
230: if (alt_p >= alt_endp)
231: complain("Too many alternates; max %d.", NALTS);
232: /* close off previous alternate */
233: *comp_ptr++ = CLOSEP;
234: *comp_ptr++ = *--parenp;
235: *comp_ptr++ = EOP;
236: *alt_p++ = comp_ptr;
237:
238: /* start a new one */
239: re_blk->r_nparens = 0;
240: *comp_ptr++ = OPENP;
241: *comp_ptr++ = re_blk->r_nparens;
242: *parenp++ = re_blk->r_nparens++;
243: start_p = comp_ptr;
244: break;
245:
246: case '1':
247: case '2':
248: case '3':
249: case '4':
250: case '5':
251: case '6':
252: case '7':
253: case '8':
254: case '9':
255: *comp_ptr++ = BACKREF;
256: *comp_ptr++ = c - '0';
257: break;
258:
259: case '<':
260: *comp_ptr++ = AT_BOW;
261: break;
262:
263: case '>':
264: *comp_ptr++ = AT_EOW;
265: break;
266:
267: default:
268: goto defchar;
269: }
270: break;
271:
272: case ',':
273: if (kind != IN_CB)
274: goto defchar;
275: goto outahere;
276:
277: case '.':
278: *comp_ptr++ = ANYC;
279: break;
280:
281: case '^':
282: if (comp_ptr == start_p) {
283: *comp_ptr++ = AT_BOL;
284: break;
285: }
286: goto defchar;
287:
288: case '$':
289: if ((REpeekc = REgetc()) != 0 && REpeekc != '\\')
290: goto defchar;
291: *comp_ptr++ = AT_EOL;
292: break;
293:
294: case '[':
295: {
296: int chrcnt;
297:
298: *comp_ptr++ = ONE_OF;
299: if (comp_ptr + SETSIZE >= comp_endp)
300: goto toolong;
301: byte_zero(comp_ptr, (size_t) SETSIZE);
302: if ((REpeekc = REgetc()) == '^') {
303: *this_verb = NONE_OF;
304: /* Get it for real this time. */
305: (void) REgetc();
306: }
307: chrcnt = 0;
308: while ((c = REgetc()) != ']' && c != 0) {
309: if (c == '\\') {
310: c = REgetc();
311: if (c == 0)
312: break;
313: } else if ((REpeekc = REgetc()) == '-') {
314: int i;
315:
316: i = c;
317: (void) REgetc(); /* reread '-' */
318: c = REgetc();
319: if (c == 0)
320: break;
321: while (i < c) {
322: comp_ptr[SETBYTE(i)] |= SETBIT(i);
323: i += 1;
324: }
325: }
326: comp_ptr[SETBYTE(c)] |= SETBIT(c);
327: chrcnt += 1;
328: }
329: if (c == 0)
330: complain("Missing ].");
331: if (chrcnt == 0)
332: complain("Empty [].");
333: comp_ptr += SETSIZE;
334: break;
335: }
336:
337: case '*':
338: if (prev_verb == NULL || *prev_verb <= NOSTR || (*prev_verb&STAR)!=0)
339: goto defchar;
340:
341: if (*prev_verb == NORMC || *prev_verb == CINDC) {
342: char lastc = comp_ptr[-1];
343:
344: /* The * operator applies only to the
345: * previous character. Since we were
346: * building a string-matching command
347: * (NORMC or CINDC), we must split it
348: * up and work with the last character.
349: *
350: * Note that the STARed versions of these
351: * commands do not operate on strings, and
352: * so do not need or have character counts.
353: */
354:
355: if (prev_verb[1] == 1) {
356: /* Only one char in string:
357: * delete old command.
358: */
359: this_verb = prev_verb;
360: } else {
361: /* Several chars in string:
362: * strip off the last.
363: * New verb is derived from old.
364: */
365: prev_verb[1] -= 1;
366: this_verb -= 1;
367: *this_verb = *prev_verb;
368: }
369: comp_ptr = this_verb + 1;
370: *comp_ptr++ = lastc;
371: } else {
372: /* This command is just the previous one,
373: * whose verb we will modify.
374: */
375: this_verb = prev_verb;
376: }
377: *this_verb |= STAR;
378: break;
379: default:
380: defchar:
381: if ((prev_verb == NULL) ||
382: !(*prev_verb == NORMC || *prev_verb == CINDC)) {
383: /* create new string command */
384: *comp_ptr++ = (CaseIgnore) ? CINDC : NORMC;
385: *comp_ptr++ = 0;
386: } else {
387: /* merge this into previous string command */
388: this_verb = prev_verb;
389: }
390: this_verb[1] += 1;
391: *comp_ptr++ = c;
392: break;
393: }
394: }
395: outahere:
396:
397: /* End of pattern, let's do some error checking. */
398: if (kind == OKAY_RE) {
399: *comp_ptr++ = CLOSEP;
400: *comp_ptr++ = *--parenp;
401: }
402: if (parenp != parens)
403: complain("Unmatched ()'s.");
404: if (kind == IN_CB && c == 0) /* end of pattern with missing \}. */
405: complain("Missing \\}.");
406: *comp_ptr++ = EOP;
407:
408: return ret_code;
409: }
410:
411: private char *pstrtlst[NPAR], /* index into re_blk->r_lbuf */
412: *pendlst[NPAR],
413: *REbolp, /* begining-of-line pointer */
414: *locrater, /* roof of last substitution */
415: *loc1, /* start of matched text */
416: *loc2; /* roof of matched text */
417:
418: int REbom, /* beginning and end columns of match */
419: REeom,
420: REdelta; /* increase in line length due to last re_dosub */
421:
422: private int
423: backref(n, linep)
424: int n;
425: register char *linep;
426: {
427: register char *backsp,
428: *backep;
429:
430: backsp = pstrtlst[n];
431: backep = pendlst[n];
432: while (*backsp++ == *linep++)
433: if (backsp >= backep)
434: return 1;
435: return 0;
436: }
437:
438: private int
439: member(comp_ptr, c, af)
440: register char *comp_ptr;
441: register int c,
442: af;
443: {
444: if (c == 0)
445: return 0; /* try to match EOL always fails */
446: if (comp_ptr[SETBYTE(c)] & SETBIT(c))
447: return af;
448: return !af;
449: }
450:
451: private int
452: REmatch(linep, comp_ptr)
453: register char *linep,
454: *comp_ptr;
455: {
456: char *first_p;
457: register int n;
458:
459: for (;;) switch (*comp_ptr++) {
460: case NORMC:
461: n = *comp_ptr++;
462: while (--n >= 0)
463: if (*linep++ != *comp_ptr++)
464: return NO;
465: continue;
466:
467: case CINDC: /* case independent comparison */
468: n = *comp_ptr++;
469: while (--n >= 0)
470: if (!cind_cmp(*linep++, *comp_ptr++))
471: return NO;
472: continue;
473:
474: case EOP:
475: loc2 = linep;
476: REeom = (loc2 - REbolp);
477: return YES; /* Success! */
478:
479: case AT_BOL:
480: if (linep == REbolp && linep != locrater)
481: continue;
482: return NO;
483:
484: case AT_EOL:
485: if (*linep == '\0')
486: continue;
487: return NO;
488:
489: case ANYC:
490: if (*linep++ != 0)
491: continue;
492: return NO;
493:
494: case AT_BOW:
495: if (linep != locrater && ismword(*linep)
496: && (linep == REbolp || !ismword(linep[-1])))
497: continue;
498: return NO;
499:
500: case AT_EOW:
501: if (linep != locrater && (*linep == 0 || !ismword(*linep)) &&
502: (linep != REbolp && ismword(linep[-1])))
503: continue;
504: return NO;
505:
506: case ONE_OF:
507: case NONE_OF:
508: if (member(comp_ptr, *linep++, comp_ptr[-1] == ONE_OF)) {
509: comp_ptr += SETSIZE;
510: continue;
511: }
512: return NO;
513:
514: case OPENP:
515: pstrtlst[*comp_ptr++] = linep;
516: continue;
517:
518: case CLOSEP:
519: pendlst[*comp_ptr++] = linep;
520: continue;
521:
522: case BACKREF:
523: if (pstrtlst[n = *comp_ptr++] == 0) {
524: s_mess("\\%d was not specified.", n + 1);
525: return NO;
526: }
527: if (backref(n, linep)) {
528: linep += pendlst[n] - pstrtlst[n];
529: continue;
530: }
531: return NO;
532:
533: case CURLYB:
534: {
535: int wcnt,
536: any;
537:
538: wcnt = *comp_ptr++;
539: any = 0;
540:
541: while (--wcnt >= 0) {
542: if (any == 0)
543: any = REmatch(linep, comp_ptr + 1);
544: comp_ptr += *comp_ptr;
545: }
546: if (any == 0)
547: return NO;
548: linep = loc2;
549: continue;
550: }
551:
552: case ANYC | STAR:
553: first_p = linep;
554: while (*linep++)
555: ;
556: goto star;
557:
558: case NORMC | STAR:
559: first_p = linep;
560: while (*comp_ptr == *linep++)
561: ;
562: comp_ptr += 1;
563: goto star;
564:
565: case CINDC | STAR:
566: first_p = linep;
567: while (cind_cmp(*comp_ptr, *linep++))
568: ;
569: comp_ptr += 1;
570: goto star;
571:
572: case ONE_OF | STAR:
573: case NONE_OF | STAR:
574: first_p = linep;
575: while (member(comp_ptr, *linep++, comp_ptr[-1] == (ONE_OF | STAR)))
576: ;
577: comp_ptr += SETSIZE;
578: /* fall through */
579: star:
580: /* linep points *after* first unmatched char.
581: * first_p points at where starred element started matching.
582: */
583: while (--linep > first_p) {
584: if ((*comp_ptr != NORMC || *linep == comp_ptr[2]) &&
585: REmatch(linep, comp_ptr))
586: return YES;
587: }
588: continue;
589:
590: case BACKREF | STAR:
591: first_p = linep;
592: n = *comp_ptr++;
593: while (backref(n, linep))
594: linep += pendlst[n] - pstrtlst[n];
595: while (linep > first_p) {
596: if (REmatch(linep, comp_ptr))
597: return YES;
598: linep -= pendlst[n] - pstrtlst[n];
599: }
600: continue;
601:
602: default:
603: complain("RE error match (%d).", comp_ptr[-1]);
604: }
605: /* NOTREACHED */
606: }
607:
608: private void
609: REreset()
610: {
611: register int i;
612:
613: for (i = 0; i < NPAR; i++)
614: pstrtlst[i] = pendlst[i] = 0;
615: }
616:
617: /* Index LINE at OFFSET. If lbuf_okay is nonzero it's okay to use linebuf
618: if LINE is the current line. This should save lots of time in things
619: like paren matching in LISP mode. Saves all that copying from linebuf
620: to a local buffer. substitute() is the guy who calls re_lindex with
621: lbuf_okay as 0, since the substitution gets placed in linebuf ...
622: doesn't work too well when the source and destination strings are the
623: same. I hate all these arguments!
624:
625: This code is cumbersome, repetetive for reasons of efficiency. Fast
626: search is a must as far as I am concerned. */
627:
628: int
629: re_lindex(line, offset, re_blk, lbuf_okay, crater)
630: Line *line;
631: int offset;
632: struct RE_block *re_blk;
633: int lbuf_okay;
634: int crater; /* offset of previous substitute (or -1) */
635: {
636: register char *p;
637: register int firstc = re_blk->r_firstc;
638: register int anchored = re_blk->r_anchored;
639: int re_dir = REdirection;
640: char **alts = re_blk->r_alternates;
641:
642: REreset();
643: if (lbuf_okay) {
644: REbolp = lbptr(line);
645: if (offset == -1)
646: offset = strlen(REbolp); /* arg! */
647: } else {
648: REbolp = ltobuf(line, re_blk->r_lbuf);
649: if (offset == -1) { /* Reverse search, find end of line. */
650: offset = Jr_Len; /* Just Read Len. */
651: }
652: }
653:
654: if (anchored == YES) {
655: if (re_dir == FORWARD) {
656: if (offset != 0 || crater != -1)
657: return NO;
658: } else
659: offset = 0;
660: }
661:
662: p = REbolp + offset;
663: locrater = REbolp + crater;
664:
665: if (firstc != '\0') {
666: char *first_alt = *alts;
667:
668: if (re_dir == FORWARD) {
669: while (CaseEquiv[*p] != firstc || !REmatch(p, first_alt))
670: if (*p++ == '\0')
671: return NO;
672: } else {
673: while (CaseEquiv[*p] != firstc || !REmatch(p, first_alt))
674: if (--p < REbolp)
675: return NO;
676: }
677: } else {
678: for (;;) {
679: register char **altp = alts;
680:
681: while (*altp != NULL)
682: if (REmatch(p, *altp++))
683: goto success;
684: if (anchored ||
685: (re_dir == FORWARD ? *p++ == '\0' : --p < REbolp))
686: return NO;
687: }
688: success:;
689: }
690: loc1 = p;
691: REbom = loc1 - REbolp;
692:
693: return YES;
694: }
695:
696: int okay_wrap = 0; /* Do a wrap search ... not when we're
697: parsing errors ... */
698:
699: Bufpos *
700: dosearch(pattern, dir, re)
701: char *pattern;
702: int dir,
703: re;
704: {
705: Bufpos *pos;
706: struct RE_block re_blk; /* global re-compiled buffer */
707:
708: if (bobp() && eobp()) /* Can't match! There's no buffer. */
709: return 0;
710:
711: REcompile(pattern, re, &re_blk);
712:
713: pos = docompiled(dir, &re_blk);
714: return pos;
715: }
716:
717: Bufpos *
718: docompiled(dir, re_blk)
719: int dir;
720: register struct RE_block *re_blk;
721: {
722: static Bufpos ret;
723: register Line *lp;
724: register int offset;
725: int we_wrapped = NO;
726:
727: lsave();
728: /* Search now lsave()'s so it doesn't make any assumptions on
729: whether the the contents of curline/curchar are in linebuf.
730: Nowhere does search write all over linebuf. However, we have to
731: be careful about what calls we make here, because many of them
732: assume (and rightly so) that curline is in linebuf. */
733:
734: REdirection = dir;
735: lp = curline;
736: offset = curchar;
737: if (dir == BACKWARD) {
738: if (bobp()) {
739: if (okay_wrap && WrapScan)
740: goto doit;
741: return 0;
742: }
743: /* here we simulate BackChar() */
744: if (bolp()) {
745: lp = lp->l_prev;
746: offset = length(lp);
747: } else
748: offset -= 1;
749: } else if ((dir == FORWARD) &&
750: (lbptr(lp)[offset] == '\0') &&
751: !lastp(lp)) {
752: lp = lp->l_next;
753: offset = 0;
754: }
755:
756: do {
757: if (re_lindex(lp, offset, re_blk, YES, -1))
758: break;
759: doit: lp = (dir == FORWARD) ? lp->l_next : lp->l_prev;
760: if (lp == 0) {
761: if (okay_wrap && WrapScan) {
762: lp = (dir == FORWARD) ?
763: curbuf->b_first : curbuf->b_last;
764: we_wrapped = YES;
765: } else
766: break;
767: }
768: if (dir == FORWARD)
769: offset = 0;
770: else
771: offset = -1; /* signals re_lindex ... */
772: } while (lp != curline);
773:
774: if (lp == curline && we_wrapped)
775: lp = 0;
776: if (lp == 0)
777: return 0;
778: ret.p_line = lp;
779: ret.p_char = (dir == FORWARD) ? REeom : REbom;
780: return &ret;
781: }
782:
783: private char *
784: insert(off, endp, which)
785: char *off,
786: *endp;
787: int which;
788: {
789: register char *pp;
790: register int n;
791:
792: n = pendlst[which] - pstrtlst[which];
793: pp = pstrtlst[which];
794: while (--n >= 0) {
795: *off++ = *pp++;
796: if (off >= endp)
797: len_error(ERROR);
798: }
799: return off;
800: }
801:
802: /* Perform the substitution. If DELP is nonzero the matched string is
803: deleted, i.e., the substitution string is not inserted. */
804:
805: void
806: re_dosub(re_blk, tobuf, delp)
807: struct RE_block *re_blk;
808: char *tobuf;
809: int delp;
810: {
811: register char *tp,
812: *rp;
813: char *endp;
814:
815: tp = tobuf;
816: endp = tp + LBSIZE;
817: rp = re_blk->r_lbuf;
818:
819: while (rp < loc1)
820: *tp++ = *rp++;
821:
822: if (!delp) {
823: register int c;
824:
825: rp = rep_str;
826: while ((c = *rp++) != '\0') {
827: if (c == '\\') {
828: c = *rp++;
829: if (c >= '0' && c < re_blk->r_nparens + '0') {
830: tp = insert(tp, endp, c - '0');
831: continue;
832: }
833: if (c == '\0') {
834: *tp++ = '\\';
835: rp--; /* be sure to hit again */
836: }
837: }
838: *tp++ = c;
839: if (tp >= endp)
840: len_error(ERROR);
841: }
842: }
843: rp = loc2;
844: REdelta = -REeom;
845: REeom = tp - tobuf;
846: REdelta += REeom;
847: if (loc1==rp && *rp!='\0') {
848: /* Skip an extra character if the matched text was a null
849: * string, but don't skip over the end of line. This is to
850: * prevent an infinite number of replacements in the same
851: * position, e.g., replace "^" with "".
852: */
853: REeom += 1;
854: }
855: loc2 = re_blk->r_lbuf + REeom;
856: while ((*tp++ = *rp++) != '\0')
857: if (tp >= endp)
858: len_error(ERROR);
859: }
860:
861: void
862: putmatch(which, buf, size)
863: int which;
864: char *buf;
865: size_t size;
866: {
867: *(insert(buf, buf + size, which)) = '\0';
868: }
869:
870: void
871: setsearch(str)
872: char *str;
873: {
874: strcpy(searchstr, str);
875: }
876:
877: char *
878: getsearch()
879: {
880: return searchstr;
881: }
882:
883: void
884: RErecur()
885: {
886: char repbuf[sizeof rep_str];
887: Mark *m = MakeMark(curline, REbom, M_FLOATER);
888:
889: message("Type C-X C-C to continue with query replace.");
890:
891: byte_copy(rep_str, repbuf, sizeof rep_str);
892: Recur();
893: byte_copy(repbuf, rep_str, sizeof rep_str);
894: if (!is_an_arg())
895: ToMark(m);
896: DelMark(m);
897: }
898:
899: void
900: ForSearch()
901: {
902: search(FORWARD, UseRE, YES);
903: }
904:
905: void
906: RevSearch()
907: {
908: search(BACKWARD, UseRE, YES);
909: }
910:
911: void
912: FSrchND()
913: {
914: search(FORWARD, UseRE, NO);
915: }
916:
917: void
918: RSrchND()
919: {
920: search(BACKWARD, UseRE, NO);
921: }
922:
923: private void
924: search(dir, re, setdefault)
925: int dir,
926: re,
927: setdefault;
928: {
929: Bufpos *newdot;
930: char *s;
931:
932: s = ask(searchstr, ProcFmt);
933: if (setdefault)
934: setsearch(s);
935: okay_wrap = YES;
936: newdot = dosearch(s, dir, re);
937: okay_wrap = NO;
938: if (newdot == 0) {
939: if (WrapScan)
940: complain("No \"%s\" in buffer.", s);
941: else
942: complain("No \"%s\" found to %s.", s,
943: (dir == FORWARD) ? "bottom" : "top");
944: }
945: PushPntp(newdot->p_line);
946: SetDot(newdot);
947: }
948:
949: /* Do we match PATTERN at OFFSET in BUF? */
950:
951: int
952: LookingAt(pattern, buf, offset)
953: char *pattern,
954: *buf;
955: int offset;
956: {
957: struct RE_block re_blk;
958: char **alt = re_blk.r_alternates;
959:
960: REcompile(pattern, YES, &re_blk);
961: REreset();
962: locrater = NULL;
963: REbolp = buf;
964:
965: while (*alt)
966: if (REmatch(buf + offset, *alt++))
967: return YES;
968: return NO;
969: }
970:
971: int
972: look_at(expr)
973: char *expr;
974: {
975: struct RE_block re_blk;
976:
977: REcompile(expr, 0, &re_blk);
978: REreset();
979: locrater = NULL;
980: REbolp = linebuf;
981: if (REmatch(linebuf + curchar, re_blk.r_alternates[0]))
982: return YES;
983: return NO;
984: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.