1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21
22 /*
23 * Copyright (c) 1989, 2010, Oracle and/or its affiliates. All rights reserved.
24 */
25
26 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
27 /* All Rights Reserved */
28
29
30 /* Copyright (c) 1981 Regents of the University of California */
31
32 #include "ex.h"
33 #include "ex_tty.h"
34 #include "ex_vis.h"
35 #ifndef PRESUNEUC
36 #include <wctype.h>
37 /* Undef putchar/getchar if they're defined. */
38 #ifdef putchar
39 # undef putchar
40 #endif
41 #ifdef getchar
42 # undef getchar
43 #endif
44 #endif /* PRESUNEUC */
45
46 extern size_t strlcpy(char *, const char *, size_t);
47
48 /*
49 * Low level routines for operations sequences,
50 * and mostly, insert mode (and a subroutine
51 * to read an input line, including in the echo area.)
52 */
53 extern unsigned char *vUA1, *vUA2; /* extern; also in ex_vops.c */
54 extern unsigned char *vUD1, *vUD2; /* extern; also in ex_vops.c */
55
56 #ifdef XPG6
57 /* XPG6 assertion 313 & 254 [count]r\n : Also used in ex_vmain.c */
58 extern int redisplay;
59 #endif
60
61 int vmaxrep(unsigned char, int);
62 static void imultlinerep(int, line *, int, int);
63 static void omultlinerep(int, line *, int);
64 #ifdef XPG6
65 static void rmultlinerep(int, int);
66 #endif
67 void fixdisplay(void);
68
69 /*
70 * Obleeperate characters in hardcopy
71 * open with \'s.
72 */
73 void
bleep(int i,unsigned char * cp)74 bleep(int i, unsigned char *cp)
75 {
76
77 i -= lcolumn(nextchr(cp));
78 do
79 putchar('\\' | QUOTE);
80 while (--i >= 0);
81 rubble = 1;
82 }
83
84 /*
85 * Common code for middle part of delete
86 * and change operating on parts of lines.
87 */
88 int
vdcMID(void)89 vdcMID(void)
90 {
91 unsigned char *cp;
92
93 squish();
94 setLAST();
95 if (FIXUNDO)
96 vundkind = VCHNG, CP(vutmp, linebuf);
97 if (wcursor < cursor)
98 cp = wcursor, wcursor = cursor, cursor = cp;
99 vUD1 = vUA1 = vUA2 = cursor; vUD2 = wcursor;
100 /*
101 * XPG6 assertion 273: Set vmcurs so that undo positions the
102 * cursor column correctly when we've moved off the initial line
103 * that was changed, as with the C, c, and s commands,
104 * when G has moved us off the line, or when a
105 * multi-line change was done.
106 */
107 fixundo();
108 return (lcolumn(wcursor));
109 }
110
111 /*
112 * Take text from linebuf and stick it
113 * in the VBSIZE buffer BUF. Used to save
114 * deleted text of part of line.
115 */
116 void
takeout(unsigned char * BUF)117 takeout(unsigned char *BUF)
118 {
119 unsigned char *cp;
120
121 if (wcursor < linebuf)
122 wcursor = linebuf;
123 if (cursor == wcursor) {
124 (void) beep();
125 return;
126 }
127 if (wcursor < cursor) {
128 cp = wcursor;
129 wcursor = cursor;
130 cursor = cp;
131 }
132 setBUF(BUF);
133 if ((unsigned char)BUF[128] == 0200)
134 (void) beep();
135 }
136
137 /*
138 * Are we at the end of the printed representation of the
139 * line? Used internally in hardcopy open.
140 */
141 int
ateopr(void)142 ateopr(void)
143 {
144 wchar_t i, c;
145 wchar_t *cp = vtube[destline] + destcol;
146
147 for (i = WCOLS - destcol; i > 0; i--) {
148 c = *cp++;
149 if (c == 0) {
150 /*
151 * Optimization to consider returning early, saving
152 * CPU time. We have to make a special check that
153 * we aren't missing a mode indicator.
154 */
155 if (destline == WECHO && destcol < WCOLS-11 && vtube[WECHO][WCOLS-20])
156 return 0;
157 return (1);
158 }
159 if (c != ' ' && (c & QUOTE) == 0)
160 return (0);
161 }
162 return (1);
163 }
164
165 /*
166 * Append.
167 *
168 * This routine handles the top level append, doing work
169 * as each new line comes in, and arranging repeatability.
170 * It also handles append with repeat counts, and calculation
171 * of autoindents for new lines.
172 */
173 bool vaifirst;
174 bool gobbled;
175 unsigned char *ogcursor;
176
177 static int INSCDCNT; /* number of ^D's (backtabs) in insertion buffer */
178
179 static int inscdcnt; /*
180 * count of ^D's (backtabs) not seen yet when doing
181 * repeat of insertion
182 */
183
184 void
vappend(int ch,int cnt,int indent)185 vappend(int ch, int cnt, int indent)
186 {
187 int i;
188 unsigned char *gcursor;
189 bool escape;
190 int repcnt, savedoomed;
191 short oldhold = hold;
192 int savecnt = cnt;
193 line *startsrcline;
194 int startsrccol, endsrccol;
195 int gotNL = 0;
196 int imultlinecnt = 0;
197 int omultlinecnt = 0;
198
199 if ((savecnt > 1) && (ch == 'o' || ch == 'O')) {
200 omultlinecnt = 1;
201 }
202 #ifdef XPG6
203 if ((savecnt > 1) && (ch == 'a' || ch == 'A' || ch == 'i' || ch == 'I'))
204 imultlinecnt = 1;
205 #endif /* XPG6 */
206
207 /*
208 * Before a move in hardopen when the line is dirty
209 * or we are in the middle of the printed representation,
210 * we retype the line to the left of the cursor so the
211 * insert looks clean.
212 */
213
214 if (ch != 'o' && state == HARDOPEN && (rubble || !ateopr())) {
215 rubble = 1;
216 gcursor = cursor;
217 i = *gcursor;
218 *gcursor = ' ';
219 wcursor = gcursor;
220 (void) vmove();
221 *gcursor = i;
222 }
223 /*
224 * If vrep() passed indent = 0, this is the 'r' command,
225 * so don't autoindent until the last char.
226 */
227 vaifirst = indent == 0;
228
229 /*
230 * Handle replace character by (eventually)
231 * limiting the number of input characters allowed
232 * in the vgetline routine.
233 */
234 if (ch == 'r')
235 repcnt = 2;
236 else
237 repcnt = 0;
238
239 /*
240 * If an autoindent is specified, then
241 * generate a mixture of blanks to tabs to implement
242 * it and place the cursor after the indent.
243 * Text read by the vgetline routine will be placed in genbuf,
244 * so the indent is generated there.
245 */
246 if (value(vi_AUTOINDENT) && indent != 0) {
247 unsigned char x;
248 gcursor = genindent(indent);
249 *gcursor = 0;
250 vgotoCL(nqcolumn(lastchr(linebuf, cursor), genbuf));
251 } else {
252 gcursor = genbuf;
253 *gcursor = 0;
254 if (ch == 'o')
255 vfixcurs();
256 }
257
258 /*
259 * Prepare for undo. Pointers delimit inserted portion of line.
260 */
261 vUA1 = vUA2 = cursor;
262
263 /*
264 * If we are not in a repeated command and a ^@ comes in
265 * then this means the previous inserted text.
266 * If there is none or it was too long to be saved,
267 * then beep() and also arrange to undo any damage done
268 * so far (e.g. if we are a change.)
269 */
270 switch (ch) {
271 case 'r':
272 break;
273 case 'a':
274 /*
275 * TRANSLATION_NOTE
276 * "A" is a terse mode message corresponding to
277 * "APPEND MODE".
278 * Translated message of "A" must be 1 character (not byte).
279 * Or, just leave it.
280 */
281 if (value(vi_TERSE)) {
282 vshowmode(gettext("A"));
283 } else {
284 vshowmode(gettext("APPEND MODE"));
285 }
286 break;
287 case 's':
288 /*
289 * TRANSLATION_NOTE
290 * "S" is a terse mode message corresponding to
291 * "SUBSTITUTE MODE".
292 * Translated message of "S" must be 1 character (not byte).
293 * Or, just leave it.
294 */
295 if (value(vi_TERSE)) {
296 vshowmode(gettext("S"));
297 } else {
298 vshowmode(gettext("SUBSTITUTE MODE"));
299 }
300 break;
301 case 'c':
302 /*
303 * TRANSLATION_NOTE
304 * "C" is a terse mode message corresponding to
305 * "CHANGE MODE".
306 * Translated message of "C" must be 1 character (not byte).
307 * Or, just leave it.
308 */
309 if (value(vi_TERSE)) {
310 vshowmode(gettext("C"));
311 } else {
312 vshowmode(gettext("CHANGE MODE"));
313 }
314 break;
315 case 'R':
316 /*
317 * TRANSLATION_NOTE
318 * "R" is a terse mode message corresponding to
319 * "REPLACE MODE".
320 * Translated message of "R" must be 1 character (not byte).
321 * Or, just leave it.
322 */
323 if (value(vi_TERSE)) {
324 vshowmode(gettext("R"));
325 } else {
326 vshowmode(gettext("REPLACE MODE"));
327 }
328 break;
329 case 'o':
330 /*
331 * TRANSLATION_NOTE
332 * "O" is a terse mode message corresponding to
333 * "OPEN MODE".
334 * Translated message of "O" must be 1 character (not byte).
335 * Or, just leave it.
336 */
337 if (value(vi_TERSE)) {
338 vshowmode(gettext("O"));
339 } else {
340 vshowmode(gettext("OPEN MODE"));
341 }
342 break;
343 case 'i':
344 /*
345 * TRANSLATION_NOTE
346 * "I" is a terse mode message corresponding to
347 * "INSERT MODE" and the following "INPUT MODE".
348 * Translated message of "I" must be 1 character (not byte).
349 * Or, just leave it.
350 */
351 if (value(vi_TERSE)) {
352 vshowmode(gettext("I"));
353 } else {
354 vshowmode(gettext("INSERT MODE"));
355 }
356 break;
357 default:
358 /*
359 * TRANSLATION_NOTE
360 * "I" is a terse mode message corresponding to
361 * "INPUT MODE" and the previous "INSERT MODE".
362 * Translated message of "I" must be 1 character (not byte).
363 * Or, just leave it.
364 */
365 if (value(vi_TERSE)) {
366 vshowmode(gettext("I"));
367 } else {
368 vshowmode(gettext("INPUT MODE"));
369 }
370 }
371 ixlatctl(1);
372 if ((vglobp && *vglobp == 0) || peekbr()) {
373 if (INS[128] == 0200) {
374 (void) beep();
375 if (!splitw)
376 ungetkey('u');
377 doomed = 0;
378 hold = oldhold;
379 return;
380 }
381 /*
382 * Unread input from INS.
383 * An escape will be generated at end of string.
384 * Hold off n^^2 type update on dumb terminals.
385 */
386 vglobp = INS;
387 inscdcnt = INSCDCNT;
388 hold |= HOLDQIK;
389 } else if (vglobp == 0) {
390 /*
391 * Not a repeated command, get
392 * a new inserted text for repeat.
393 */
394 INS[0] = 0;
395 INS[128] = 0;
396 INSCDCNT = 0;
397 }
398
399 /*
400 * For wrapmargin to hack away second space after a '.'
401 * when the first space caused a line break we keep
402 * track that this happened in gobblebl, which says
403 * to gobble up a blank silently.
404 */
405 gobblebl = 0;
406
407 startsrcline = dot;
408 startsrccol = cursor - linebuf;
409
410 /*
411 * Text gathering loop.
412 * New text goes into genbuf starting at gcursor.
413 * cursor preserves place in linebuf where text will eventually go.
414 */
415 if (*cursor == 0 || state == CRTOPEN)
416 hold |= HOLDROL;
417 for (;;) {
418 if (ch == 'r' && repcnt == 0)
419 escape = 0;
420 else {
421 ixlatctl(1);
422 /*
423 * When vgetline() returns, gcursor is
424 * pointing to '\0' and vgetline() has
425 * read an ESCAPE or NL.
426 */
427 gcursor = vgetline(repcnt, gcursor, &escape, ch);
428 if (escape == '\n') {
429 gotNL = 1;
430 #ifdef XPG6
431 if (ch == 'r') {
432 /*
433 * XPG6 assertion 313 [count]r\n :
434 * Arrange to set cursor correctly.
435 */
436 endsrccol = gcursor - genbuf - 1;
437 }
438 #endif /* XPG6 */
439 } else {
440 /*
441 * Upon escape, gcursor is pointing to '\0'
442 * terminating the string in genbuf.
443 */
444 endsrccol = gcursor - genbuf - 1;
445 }
446 ixlatctl(0);
447
448 /*
449 * After an append, stick information
450 * about the ^D's and ^^D's and 0^D's in
451 * the repeated text buffer so repeated
452 * inserts of stuff indented with ^D as backtab's
453 * can work.
454 */
455 if (HADUP)
456 addtext("^");
457 else if (HADZERO)
458 addtext("0");
459 if(!vglobp)
460 INSCDCNT = CDCNT;
461 while (CDCNT > 0) {
462 addtext("\004");
463 CDCNT--;
464 }
465 if (gobbled)
466 addtext(" ");
467 addtext(ogcursor);
468 }
469 repcnt = 0;
470
471 /*
472 * Smash the generated and preexisting indents together
473 * and generate one cleanly made out of tabs and spaces
474 * if we are using autoindent and this isn't 'r' command.
475 */
476 if (!vaifirst && value(vi_AUTOINDENT)) {
477 i = fixindent(indent);
478 if (!HADUP)
479 indent = i;
480 gcursor = strend(genbuf);
481 }
482
483 /*
484 * Set cnt to 1 to avoid repeating the text on the same line.
485 * Do this for commands 'i', 'I', 'a', and 'A', if we're
486 * inserting anything with a newline for XPG6. Always do this
487 * for commands 'o' and 'O'.
488 */
489 if ((imultlinecnt && gotNL) || omultlinecnt) {
490 cnt = 1;
491 }
492
493 /*
494 * Limit the repetition count based on maximum
495 * possible line length; do output implied
496 * by further count (> 1) and cons up the new line
497 * in linebuf.
498 */
499 cnt = vmaxrep(ch, cnt);
500 /*
501 * cursor points to linebuf
502 * Copy remaining old text (cursor) in original
503 * line to after new text (gcursor + 1) in genbuf.
504 */
505 CP(gcursor + 1, cursor);
506 /*
507 * For [count] r \n command, when replacing [count] chars
508 * with '\n', this loop replaces [count] chars with "".
509 */
510 do {
511 /* cp new text (genbuf) into linebuf (cursor) */
512 CP(cursor, genbuf);
513 if (cnt > 1) {
514 int oldhold = hold;
515
516 Outchar = vinschar;
517 hold |= HOLDQIK;
518 viprintf("%s", genbuf);
519 hold = oldhold;
520 Outchar = vputchar;
521 }
522 /* point cursor after new text in linebuf */
523 cursor += gcursor - genbuf;
524 } while (--cnt > 0);
525 endim();
526 vUA2 = cursor;
527 /* add the remaining old text after the cursor */
528 if (escape != '\n')
529 CP(cursor, gcursor + 1);
530
531 /*
532 * If doomed characters remain, clobber them,
533 * and reopen the line to get the display exact.
534 * eg. c$ to change to end of line
535 */
536 if (state != HARDOPEN) {
537 DEPTH(vcline) = 0;
538 savedoomed = doomed;
539 if (doomed > 0) {
540 int cind = cindent();
541
542 physdc(cind, cind + doomed);
543 doomed = 0;
544 }
545 if(MB_CUR_MAX > 1)
546 rewrite = _ON;
547 i = vreopen(LINE(vcline), lineDOT(), vcline);
548 if(MB_CUR_MAX > 1)
549 rewrite = _OFF;
550 #ifdef TRACE
551 if (trace)
552 fprintf(trace, "restoring doomed from %d to %d\n", doomed, savedoomed);
553 #endif
554 if (ch == 'R')
555 doomed = savedoomed;
556 }
557
558 /*
559 * Unless we are continuing on to another line
560 * (got a NL), break out of the for loop (got
561 * an ESCAPE).
562 */
563 if (escape != '\n') {
564 vshowmode("");
565 break;
566 }
567
568 /*
569 * Set up for the new line.
570 * First save the current line, then construct a new
571 * first image for the continuation line consisting
572 * of any new autoindent plus the pushed ahead text.
573 */
574 killU();
575 addtext(gobblebl ? " " : "\n");
576 /* save vutmp (for undo state) into temp file */
577 vsave();
578 cnt = 1;
579 if (value(vi_AUTOINDENT)) {
580 if (value(vi_LISP))
581 indent = lindent(dot + 1);
582 else
583 if (!HADUP && vaifirst)
584 indent = whitecnt(linebuf);
585 vaifirst = 0;
586 strcLIN(vpastwh(gcursor + 1));
587 gcursor = genindent(indent);
588 *gcursor = 0;
589 if (gcursor + strlen(linebuf) > &genbuf[LBSIZE - 2])
590 gcursor = genbuf;
591 CP(gcursor, linebuf);
592 } else {
593 /*
594 * Put gcursor at start of genbuf to wipe
595 * out previous line in preparation for
596 * the next vgetline() loop.
597 */
598 CP(genbuf, gcursor + 1);
599 gcursor = genbuf;
600 }
601
602 /*
603 * If we started out as a single line operation and are now
604 * turning into a multi-line change, then we had better yank
605 * out dot before it changes so that undo will work
606 * correctly later.
607 */
608 if (FIXUNDO && vundkind == VCHNG) {
609 vremote(1, yank, 0);
610 undap1--;
611 }
612
613 /*
614 * Now do the append of the new line in the buffer,
615 * and update the display, ie: append genbuf to
616 * the file after dot. If slowopen
617 * we don't do very much.
618 */
619 vdoappend(genbuf);
620 vundkind = VMANYINS;
621 vcline++;
622 if (state != VISUAL)
623 vshow(dot, NOLINE);
624 else {
625 i += LINE(vcline - 1);
626 vopen(dot, i);
627 if (value(vi_SLOWOPEN))
628 vscrap();
629 else
630 vsync1(LINE(vcline));
631 }
632 switch (ch) {
633 case 'r':
634 break;
635 case 'a':
636 if (value(vi_TERSE)) {
637 vshowmode(gettext("A"));
638 } else {
639 vshowmode(gettext("APPEND MODE"));
640 }
641 break;
642 case 's':
643 if (value(vi_TERSE)) {
644 vshowmode(gettext("S"));
645 } else {
646 vshowmode(gettext("SUBSTITUTE MODE"));
647 }
648 break;
649 case 'c':
650 if (value(vi_TERSE)) {
651 vshowmode(gettext("C"));
652 } else {
653 vshowmode(gettext("CHANGE MODE"));
654 }
655 break;
656 case 'R':
657 if (value(vi_TERSE)) {
658 vshowmode(gettext("R"));
659 } else {
660 vshowmode(gettext("REPLACE MODE"));
661 }
662 break;
663 case 'i':
664 if (value(vi_TERSE)) {
665 vshowmode(gettext("I"));
666 } else {
667 vshowmode(gettext("INSERT MODE"));
668 }
669 break;
670 case 'o':
671 if (value(vi_TERSE)) {
672 vshowmode(gettext("O"));
673 } else {
674 vshowmode(gettext("OPEN MODE"));
675 }
676 break;
677 default:
678 if (value(vi_TERSE)) {
679 vshowmode(gettext("I"));
680 } else {
681 vshowmode(gettext("INPUT MODE"));
682 }
683 }
684 strcLIN(gcursor);
685 /* zero genbuf */
686 *gcursor = 0;
687 cursor = linebuf;
688 vgotoCL(nqcolumn(cursor - 1, genbuf));
689 } /* end for (;;) loop in vappend() */
690
691 if (imultlinecnt && gotNL) {
692 imultlinerep(savecnt, startsrcline, startsrccol, endsrccol);
693 } else if (omultlinecnt) {
694 omultlinerep(savecnt, startsrcline, endsrccol);
695 #ifdef XPG6
696 } else if (savecnt > 1 && ch == 'r' && gotNL) {
697 /*
698 * XPG6 assertion 313 & 254 : Position cursor for [count]r\n
699 * then insert [count -1] newlines.
700 */
701 endsrccol = gcursor - genbuf - 1;
702 rmultlinerep(savecnt, endsrccol);
703 #endif /* XPG6 */
704 }
705
706 /*
707 * All done with insertion, position the cursor
708 * and sync the screen.
709 */
710 hold = oldhold;
711 if ((imultlinecnt && gotNL) || omultlinecnt) {
712 fixdisplay();
713 #ifdef XPG6
714 } else if (savecnt > 1 && ch == 'r' && gotNL) {
715 fixdisplay();
716 /*
717 * XPG6 assertion 313 & 254 [count]r\n : Set flag to call
718 * fixdisplay() after operate() has finished. To be sure that
719 * the text (after the last \n followed by an indent) is always
720 * displayed, fixdisplay() is called right before getting
721 * the next command.
722 */
723 redisplay = 1;
724 #endif /* XPG6 */
725 } else if (cursor > linebuf) {
726 cursor = lastchr(linebuf, cursor);
727 #ifdef XPG6
728 /*
729 * XPG6 assertion 313 & 254 [count]r\n :
730 * For 'r' command, when the replacement char causes new
731 * lines to be created, point cursor to first non-blank.
732 * The old code, ie: cursor = lastchr(linebuf, cursor);
733 * set cursor to the blank before the first non-blank
734 * for r\n
735 */
736 if (ch == 'r' && gotNL && isblank((int)*cursor))
737 ++cursor;
738 #endif /* XPG6 */
739 }
740 if (state != HARDOPEN)
741 vsyncCL();
742 else if (cursor > linebuf)
743 back1();
744 doomed = 0;
745 wcursor = cursor;
746 (void) vmove();
747 }
748
749 /*
750 * XPG6
751 * To repeat multi-line input for [count]a, [count]A, [count]i, [count]I,
752 * or a subsequent [count]. :
753 * insert input count-1 more times.
754 */
755
756 static void
imultlinerep(int savecnt,line * startsrcline,int startsrccol,int endsrccol)757 imultlinerep(int savecnt, line *startsrcline, int startsrccol, int endsrccol)
758 {
759 int tmpcnt = 2; /* 1st insert counts as 1 repeat */
760 line *srcline, *endsrcline;
761 size_t destsize = LBSIZE - endsrccol - 1;
762
763 endsrcline = dot;
764
765 /* Save linebuf into temp file before moving off the line. */
766 vsave();
767
768 /*
769 * At this point the temp file contains the first iteration of
770 * a multi-line insert, and we need to repeat it savecnt - 1
771 * more times in the temp file. dot is the last line in the
772 * first iteration of the insert. Decrement dot so that
773 * vdoappend() will append each new line before the last line.
774 */
775 --dot;
776 --vcline;
777 /*
778 * Use genbuf to rebuild the last line in the 1st iteration
779 * of the repeated insert, then copy this line to the temp file.
780 */
781 (void) strlcpy((char *)genbuf, (char *)linebuf, sizeof (genbuf));
782 getaline(*startsrcline);
783 if (strlcpy((char *)(genbuf + endsrccol + 1),
784 (char *)(linebuf + startsrccol), destsize) >= destsize) {
785 error(gettext("Line too long"));
786 }
787 vdoappend(genbuf);
788 vcline++;
789 /*
790 * Loop from the second line of the first iteration
791 * through endsrcline, appending after dot.
792 */
793 ++startsrcline;
794
795 while (tmpcnt <= savecnt) {
796 for (srcline = startsrcline; srcline <= endsrcline;
797 ++srcline) {
798 if ((tmpcnt == savecnt) &&
799 (srcline == endsrcline)) {
800 /*
801 * The last line is already in place,
802 * just make it the current line.
803 */
804 vcline++;
805 dot++;
806 getDOT();
807 cursor = linebuf + endsrccol;
808 } else {
809 getaline(*srcline);
810 /* copy linebuf to temp file */
811 vdoappend(linebuf);
812 vcline++;
813 }
814 }
815 ++tmpcnt;
816 }
817 }
818
819 /*
820 * To repeat input for [count]o, [count]O, or a subsequent [count]. :
821 * append input count-1 more times to the end of the already added
822 * text, each time starting on a new line.
823 */
824
825 static void
omultlinerep(int savecnt,line * startsrcline,int endsrccol)826 omultlinerep(int savecnt, line *startsrcline, int endsrccol)
827 {
828 int tmpcnt = 2; /* 1st insert counts as 1 repeat */
829 line *srcline, *endsrcline;
830
831 endsrcline = dot;
832 /* Save linebuf into temp file before moving off the line. */
833 vsave();
834
835 /*
836 * Loop from the first line of the first iteration
837 * through endsrcline, appending after dot.
838 */
839 while (tmpcnt <= savecnt) {
840 for (srcline = startsrcline; srcline <= endsrcline; ++srcline) {
841 getaline(*srcline);
842 /* copy linebuf to temp file */
843 vdoappend(linebuf);
844 vcline++;
845 }
846 ++tmpcnt;
847 }
848 cursor = linebuf + endsrccol;
849 }
850
851 #ifdef XPG6
852 /*
853 * XPG6 assertion 313 & 254 : To repeat '\n' for [count]r\n
854 * insert '\n' savecnt-1 more times before the already added '\n'.
855 */
856
857 static void
rmultlinerep(int savecnt,int endsrccol)858 rmultlinerep(int savecnt, int endsrccol)
859 {
860 int tmpcnt = 2; /* 1st replacement counts as 1 repeat */
861
862 /* Save linebuf into temp file before moving off the line. */
863 vsave();
864 /*
865 * At this point the temp file contains the line followed by '\n',
866 * which is preceded by indentation if autoindent is set.
867 * '\n' must be repeated [savecnt - 1] more times in the temp file.
868 * dot is the current line containing the '\n'. Decrement dot so that
869 * vdoappend() will append each '\n' before the current '\n'.
870 * This will allow only the last line to contain any autoindent
871 * characters.
872 */
873 --dot;
874 --vcline;
875
876 /*
877 * Append after dot.
878 */
879 while (tmpcnt <= savecnt) {
880 linebuf[0] = '\0';
881 /* append linebuf below current line in temp file */
882 vdoappend(linebuf);
883 vcline++;
884 ++tmpcnt;
885 }
886 /* set the current line to the line after the last '\n' */
887 ++dot;
888 ++vcline;
889 /* point cursor after (linebuf + endsrccol) */
890 vcursaft(linebuf + endsrccol);
891 }
892 #endif /* XPG6 */
893
894 /*
895 * Similiar to a ctrl-l, however always vrepaint() in case the last line
896 * of the repeat would exceed the bottom of the screen.
897 */
898
899 void
fixdisplay(void)900 fixdisplay(void)
901 {
902 vclear();
903 vdirty(0, vcnt);
904 if (state != VISUAL) {
905 vclean();
906 vcnt = 0;
907 vmoveto(dot, cursor, 0);
908 } else {
909 vredraw(WTOP);
910 vrepaint(cursor);
911 vfixcurs();
912 }
913 }
914
915 /*
916 * Subroutine for vgetline to back up a single character position,
917 * backwards around end of lines (vgoto can't hack columns which are
918 * less than 0 in general).
919 */
920 void
back1(void)921 back1(void)
922 {
923
924 vgoto(destline - 1, WCOLS + destcol - 1);
925 }
926
927 /*
928 * Get a line into genbuf after gcursor.
929 * Cnt limits the number of input characters
930 * accepted and is used for handling the replace
931 * single character command. Aescaped is the location
932 * where we stick a termination indicator (whether we
933 * ended with an ESCAPE or a newline/return.
934 *
935 * We do erase-kill type processing here and also
936 * are careful about the way we do this so that it is
937 * repeatable. (I.e. so that your kill doesn't happen,
938 * when you repeat an insert if it was escaped with \ the
939 * first time you did it. commch is the command character
940 * involved, including the prompt for readline.
941 */
942 unsigned char *
vgetline(cnt,gcursor,aescaped,commch)943 vgetline(cnt, gcursor, aescaped, commch)
944 int cnt;
945 unsigned char *gcursor;
946 bool *aescaped;
947 unsigned char commch;
948 {
949 int c, ch;
950 unsigned char *cp, *pcp;
951 int x, y, iwhite, backsl=0;
952 unsigned char *iglobp;
953 int (*OO)() = Outchar;
954 int length, width;
955 unsigned char multic[MULTI_BYTE_MAX+1];
956 wchar_t wchar = 0;
957 unsigned char *p;
958 int len;
959
960
961 /*
962 * Clear the output state and counters
963 * for autoindent backwards motion (counts of ^D, etc.)
964 * Remember how much white space at beginning of line so
965 * as not to allow backspace over autoindent.
966 */
967
968 *aescaped = 0;
969 ogcursor = gcursor;
970 flusho();
971 CDCNT = 0;
972 HADUP = 0;
973 HADZERO = 0;
974 gobbled = 0;
975 iwhite = whitecnt(genbuf);
976 iglobp = vglobp;
977
978 /*
979 * Clear abbreviation recursive-use count
980 */
981 abbrepcnt = 0;
982 /*
983 * Carefully avoid using vinschar in the echo area.
984 */
985 if (splitw)
986 Outchar = vputchar;
987 else {
988 Outchar = vinschar;
989 vprepins();
990 }
991 for (;;) {
992 length = 0;
993 backsl = 0;
994 if (gobblebl)
995 gobblebl--;
996 if (cnt != 0) {
997 cnt--;
998 if (cnt == 0)
999 goto vadone;
1000 }
1001 c = getkey();
1002 if (c != ATTN)
1003 c &= 0377;
1004 ch = c;
1005 maphopcnt = 0;
1006 if (vglobp == 0 && Peekkey == 0 && commch != 'r')
1007 while ((ch = map(c, immacs, commch)) != c) {
1008 c = ch;
1009 if (!value(vi_REMAP))
1010 break;
1011 if (++maphopcnt > 256)
1012 error(gettext("Infinite macro loop"));
1013 }
1014 if (!iglobp) {
1015
1016 /*
1017 * Erase-kill type processing.
1018 * Only happens if we were not reading
1019 * from untyped input when we started.
1020 * Map users erase to ^H, kill to -1 for switch.
1021 */
1022 if (c == tty.c_cc[VERASE])
1023 c = CTRL('h');
1024 else if (c == tty.c_cc[VKILL])
1025 c = -1;
1026 switch (c) {
1027
1028 /*
1029 * ^? Interrupt drops you back to visual
1030 * command mode with an unread interrupt
1031 * still in the input buffer.
1032 *
1033 * ^\ Quit does the same as interrupt.
1034 * If you are a ex command rather than
1035 * a vi command this will drop you
1036 * back to command mode for sure.
1037 */
1038 case ATTN:
1039 case QUIT:
1040 ungetkey(c);
1041 goto vadone;
1042
1043 /*
1044 * ^H Backs up a character in the input.
1045 *
1046 * BUG: Can't back around line boundaries.
1047 * This is hard because stuff has
1048 * already been saved for repeat.
1049 */
1050 case CTRL('h'):
1051 bakchar:
1052 cp = lastchr(ogcursor, gcursor);
1053 if (cp < ogcursor) {
1054 if (splitw) {
1055 /*
1056 * Backspacing over readecho
1057 * prompt. Pretend delete but
1058 * don't beep.
1059 */
1060 ungetkey(c);
1061 goto vadone;
1062 }
1063 (void) beep();
1064 continue;
1065 }
1066 goto vbackup;
1067
1068 /*
1069 * ^W Back up a white/non-white word.
1070 */
1071 case CTRL('w'):
1072 wdkind = 1;
1073 for (cp = gcursor; cp > ogcursor && isspace(cp[-1]); cp--)
1074 continue;
1075 pcp = lastchr(ogcursor, cp);
1076 for (c = wordch(pcp);
1077 cp > ogcursor && wordof(c, pcp); cp = pcp, pcp = lastchr(ogcursor, cp))
1078 continue;
1079 goto vbackup;
1080
1081 /*
1082 * users kill Kill input on this line, back to
1083 * the autoindent.
1084 */
1085 case -1:
1086 cp = ogcursor;
1087 vbackup:
1088 if (cp == gcursor) {
1089 (void) beep();
1090 continue;
1091 }
1092 endim();
1093 *cp = 0;
1094 c = cindent();
1095 vgotoCL(nqcolumn(lastchr(linebuf, cursor), genbuf));
1096
1097 if (doomed >= 0)
1098 doomed += c - cindent();
1099 gcursor = cp;
1100 continue;
1101
1102 /*
1103 * \ Followed by erase or kill
1104 * maps to just the erase or kill.
1105 */
1106 case '\\':
1107 x = destcol, y = destline;
1108 putchar('\\');
1109 vcsync();
1110 c = getkey();
1111 if (c == tty.c_cc[VERASE]
1112 || c == tty.c_cc[VKILL])
1113 {
1114 vgoto(y, x);
1115 if (doomed >= 0)
1116 doomed++;
1117 multic[0] = wchar = c;
1118 length = 1;
1119 goto def;
1120 }
1121 ungetkey(c), c = '\\';
1122 backsl = 1;
1123 break;
1124
1125 /*
1126 * ^Q Super quote following character
1127 * Only ^@ is verboten (trapped at
1128 * a lower level) and \n forces a line
1129 * split so doesn't really go in.
1130 *
1131 * ^V Synonym for ^Q
1132 */
1133 case CTRL('q'):
1134 case CTRL('v'):
1135 x = destcol, y = destline;
1136 putchar('^');
1137 vgoto(y, x);
1138 c = getkey();
1139 #ifdef USG
1140 if (c == ATTN)
1141 c = tty.c_cc[VINTR];
1142 #endif
1143 if (c != NL) {
1144 if (doomed >= 0)
1145 doomed++;
1146 multic[0] = wchar = c;
1147 length = 1;
1148 goto def;
1149 }
1150 break;
1151 }
1152 }
1153
1154 /*
1155 * If we get a blank not in the echo area
1156 * consider splitting the window in the wrapmargin.
1157 */
1158 if(!backsl) {
1159 ungetkey(c);
1160 if((length = _mbftowc((char *)multic, &wchar, getkey, &Peekkey)) <= 0) {
1161 (void) beep();
1162 continue;
1163 }
1164 } else {
1165 length = 1;
1166 multic[0] = '\\';
1167 }
1168
1169 if (c != NL && !splitw) {
1170 if (c == ' ' && gobblebl) {
1171 gobbled = 1;
1172 continue;
1173 }
1174 if ((width = wcwidth(wchar)) <= 0)
1175 width = (wchar <= 0177 ? 1 : 4);
1176 if (value(vi_WRAPMARGIN) &&
1177 (outcol + width - 1 >= OCOLUMNS - value(vi_WRAPMARGIN) ||
1178 backsl && outcol==0) &&
1179 commch != 'r') {
1180 /*
1181 * At end of word and hit wrapmargin.
1182 * Move the word to next line and keep going.
1183 */
1184 unsigned char *wp;
1185 int bytelength;
1186 #ifndef PRESUNEUC
1187 unsigned char *tgcursor;
1188 wchar_t wc1, wc2;
1189 tgcursor = gcursor;
1190 #endif /* PRESUNEUC */
1191 wdkind = 1;
1192 strncpy(gcursor, multic, length);
1193 gcursor += length;
1194 if (backsl) {
1195 #ifdef PRESUNEUC
1196 if((length = mbftowc((char *)multic, &wchar, getkey, &Peekkey)) <= 0) {
1197 #else
1198 if((length = _mbftowc((char *)multic, &wchar, getkey, &Peekkey)) <= 0) {
1199 #endif /* PRESUNEUC */
1200 (void) beep();
1201 continue;
1202 }
1203 strncpy(gcursor, multic, length);
1204 gcursor += length;
1205 }
1206 *gcursor = 0;
1207 /*
1208 * Find end of previous word if we are past it.
1209 */
1210 for (cp=gcursor; cp>ogcursor && isspace(cp[-1]); cp--)
1211 ;
1212 #ifdef PRESUNEUC
1213 /* find screen width of previous word */
1214 width = 0;
1215 for(wp = cp; *wp; )
1216 #else
1217 /* count screen width of pending characters */
1218 width = 0;
1219 for(wp = tgcursor; wp < cp;)
1220 #endif /* PRESUNEUC */
1221 if((bytelength = mbtowc(&wchar, (char *)wp, MULTI_BYTE_MAX)) < 0) {
1222 width+=4;
1223 wp++;
1224 } else {
1225 int curwidth = wcwidth(wchar);
1226 if(curwidth <= 0)
1227 width += (*wp < 0200 ? 2 : 4);
1228 else
1229 width += curwidth;
1230 wp += bytelength;
1231 }
1232
1233 #ifdef PRESUNEUC
1234 if (outcol+(backsl?OCOLUMNS:0) - width >= OCOLUMNS - value(vi_WRAPMARGIN)) {
1235 #else
1236 if (outcol+(backsl?OCOLUMNS:0) + width -1 >= OCOLUMNS - value(vi_WRAPMARGIN)) {
1237 #endif /* PRESUNEUC */
1238 /*
1239 * Find beginning of previous word.
1240 */
1241 #ifdef PRESUNEUC
1242 for (; cp>ogcursor && !isspace(cp[-1]); cp--)
1243 ;
1244 #else
1245 wc1 = wc2 = 0;
1246 while (cp>ogcursor) {
1247 if (isspace(cp[-1])) {
1248 break;
1249 }
1250 if (!multibyte) {
1251 cp--;
1252 continue;
1253 }
1254 wp = (unsigned char *)(cp -
1255 MB_CUR_MAX);
1256 if (wp < ogcursor)
1257 wp = ogcursor;
1258 while (cp > wp) {
1259 /* 7tabs */if (wc2) {
1260 /* 7tabs */ if ((bytelength = mbtowc(&wc1, (char *)wp, cp-wp)) != cp-wp) {
1261 /* 7tabs */ wp++;
1262 /* 7tabs */ wc1 = 0;
1263 /* 7tabs */ continue;
1264 /* 7tabs */ }
1265 /* 7tabs */} else {
1266 /* 7tabs */ if ((bytelength = mbtowc(&wc2, (char *)wp, cp-wp)) != cp-wp) {
1267 /* 7tabs */ wp++;
1268 /* 7tabs */ wc2 = 0;
1269 /* 7tabs */ continue;
1270 /* 7tabs */ }
1271 /* 7tabs */}
1272 /* 7tabs */if (wc1) {
1273 /* 7tabs */ if (wdbdg && (!iswascii(wc1) || !iswascii(wc2))) {
1274 /* 7tabs */ if ((*wdbdg)(wc1, wc2, 2) < 5) {
1275 /* 7tabs */ goto ws;
1276 /* 7tabs */ }
1277 /* 7tabs */ }
1278 /* 7tabs */ wc2 = wc1;
1279 /* 7tabs */ wc1 = 0;
1280 /* 7tabs */ cp -= bytelength - 1;
1281 /* 7tabs */ break;
1282 /* 7tabs */} else {
1283 /* 7tabs */ cp -= bytelength - 1;
1284 /* 7tabs */ break;
1285 /* 7tabs */}
1286 }
1287 cp--;
1288 }
1289 ws:
1290 #endif /* PRESUNEUC */
1291 if (cp <= ogcursor) {
1292 /*
1293 * There is a single word that
1294 * is too long to fit. Just
1295 * let it pass, but beep for
1296 * each new letter to warn
1297 * the luser.
1298 */
1299 gcursor -= length;
1300 c = *gcursor;
1301 *gcursor = 0;
1302 (void) beep();
1303 goto dontbreak;
1304 }
1305 /*
1306 * Save it for next line.
1307 */
1308 macpush(cp, 0);
1309 #ifdef PRESUNEUC
1310 cp--;
1311 #endif /* PRESUNEUC */
1312 }
1313 macpush("\n", 0);
1314 /*
1315 * Erase white space before the word.
1316 */
1317 while (cp > ogcursor && isspace(cp[-1]))
1318 cp--; /* skip blank */
1319 gobblebl = 3;
1320 goto vbackup;
1321 }
1322 dontbreak:;
1323 }
1324
1325 /*
1326 * Word abbreviation mode.
1327 */
1328 if (anyabbrs && gcursor > ogcursor && !wordch(multic) && wordch(lastchr(ogcursor, gcursor))) {
1329 int wdtype, abno;
1330
1331 multic[length] = 0;
1332 wdkind = 1;
1333 cp = lastchr(ogcursor, gcursor);
1334 pcp = lastchr(ogcursor, cp);
1335 for (wdtype = wordch(pcp);
1336 cp > ogcursor && wordof(wdtype, pcp); cp = pcp, pcp = lastchr(ogcursor, pcp))
1337 ;
1338 *gcursor = 0;
1339 for (abno=0; abbrevs[abno].mapto; abno++) {
1340 if (eq(cp, abbrevs[abno].cap)) {
1341 if(abbrepcnt == 0) {
1342 if(reccnt(abbrevs[abno].cap, abbrevs[abno].mapto))
1343 abbrepcnt = 1;
1344 macpush(multic, 0);
1345 macpush(abbrevs[abno].mapto);
1346 goto vbackup;
1347 } else
1348 abbrepcnt = 0;
1349 }
1350 }
1351 }
1352
1353 switch (c) {
1354
1355 /*
1356 * ^M Except in repeat maps to \n.
1357 */
1358 case CR:
1359 if (vglobp) {
1360 multic[0] = wchar = c;
1361 length = 1;
1362 goto def;
1363 }
1364 c = '\n';
1365 /* FALLTHROUGH */
1366
1367 /*
1368 * \n Start new line.
1369 */
1370 case NL:
1371 *aescaped = c;
1372 goto vadone;
1373
1374 /*
1375 * escape End insert unless repeat and more to repeat.
1376 */
1377 case ESCAPE:
1378 if (lastvgk) {
1379 multic[0] = wchar = c;
1380 length = 1;
1381 goto def;
1382 }
1383 goto vadone;
1384
1385 /*
1386 * ^D Backtab.
1387 * ^T Software forward tab.
1388 *
1389 * Unless in repeat where this means these
1390 * were superquoted in.
1391 */
1392 case CTRL('t'):
1393 if (vglobp) {
1394 multic[0] = wchar = c;
1395 length = 1;
1396 goto def;
1397 }
1398 /* fall into ... */
1399
1400 *gcursor = 0;
1401 cp = vpastwh(genbuf);
1402 c = whitecnt(genbuf);
1403 if (ch == CTRL('t')) {
1404 /*
1405 * ^t just generates new indent replacing
1406 * current white space rounded up to soft
1407 * tab stop increment.
1408 */
1409 if (cp != gcursor)
1410 /*
1411 * BUG: Don't hack ^T except
1412 * right after initial
1413 * white space.
1414 */
1415 continue;
1416 cp = genindent(iwhite = backtab(c + value(vi_SHIFTWIDTH) + 1));
1417 ogcursor = cp;
1418 goto vbackup;
1419 }
1420 /* FALLTHROUGH */
1421 /*
1422 * ^D works only if we are at the (end of) the
1423 * generated autoindent. We count the ^D for repeat
1424 * purposes.
1425 */
1426 case CTRL('d'):
1427 /* check if ^d was superquoted in */
1428 if(vglobp && inscdcnt <= 0) {
1429 multic[0] = wchar = c;
1430 length = 1;
1431 goto def;
1432 }
1433 if(vglobp)
1434 inscdcnt--;
1435 *gcursor = 0;
1436 cp = vpastwh(genbuf);
1437 c = whitecnt(genbuf);
1438 if (c == iwhite && c != 0)
1439 if (cp == gcursor) {
1440 iwhite = backtab(c);
1441 CDCNT++;
1442 ogcursor = cp = genindent(iwhite);
1443 goto vbackup;
1444 } else if (&cp[1] == gcursor &&
1445 (*cp == '^' || *cp == '0')) {
1446 /*
1447 * ^^D moves to margin, then back
1448 * to current indent on next line.
1449 *
1450 * 0^D moves to margin and then
1451 * stays there.
1452 */
1453 HADZERO = *cp == '0';
1454 ogcursor = cp = genbuf;
1455 HADUP = 1 - HADZERO;
1456 CDCNT = 1;
1457 endim();
1458 back1();
1459 (void) vputchar(' ');
1460 goto vbackup;
1461 }
1462
1463 if (vglobp && vglobp - iglobp >= 2) {
1464 if ((p = vglobp - MB_CUR_MAX) < iglobp)
1465 p = iglobp;
1466 for ( ; p < &vglobp[-2]; p += len) {
1467 if ((len = mblen((char *)p, MB_CUR_MAX)) <= 0)
1468 len = 1;
1469 }
1470 if ((p == &vglobp[-2]) &&
1471 (*p == '^' || *p == '0') &&
1472 gcursor == ogcursor + 1)
1473 goto bakchar;
1474 }
1475 continue;
1476
1477 default:
1478 /*
1479 * Possibly discard control inputs.
1480 */
1481 if (!vglobp && junk(c)) {
1482 (void) beep();
1483 continue;
1484 }
1485 def:
1486 if (!backsl) {
1487 putchar(wchar);
1488 flush();
1489 }
1490 if (gcursor + length - 1 > &genbuf[LBSIZE - 2])
1491 error(gettext("Line too long"));
1492 (void)strncpy(gcursor, multic, length);
1493 gcursor += length;
1494 vcsync();
1495 if (value(vi_SHOWMATCH) && !iglobp)
1496 if (c == ')' || c == '}')
1497 lsmatch(gcursor);
1498 continue;
1499 }
1500 }
1501 vadone:
1502 *gcursor = 0;
1503 if (Outchar != termchar)
1504 Outchar = OO;
1505 endim();
1506 return (gcursor);
1507 }
1508
1509 int vgetsplit();
1510 unsigned char *vsplitpt;
1511
1512 /*
1513 * Append the line in buffer at lp
1514 * to the buffer after dot.
1515 */
1516 void
vdoappend(unsigned char * lp)1517 vdoappend(unsigned char *lp)
1518 {
1519 int oing = inglobal;
1520
1521 vsplitpt = lp;
1522 inglobal = 1;
1523 (void)append(vgetsplit, dot);
1524 inglobal = oing;
1525 }
1526
1527 /*
1528 * Subroutine for vdoappend to pass to append.
1529 */
1530 int
vgetsplit(void)1531 vgetsplit(void)
1532 {
1533
1534 if (vsplitpt == 0)
1535 return (EOF);
1536 strcLIN(vsplitpt);
1537 vsplitpt = 0;
1538 return (0);
1539 }
1540
1541 /*
1542 * Vmaxrep determines the maximum repetition factor
1543 * allowed that will yield total line length less than
1544 * LBSIZE characters and also does hacks for the R command.
1545 */
1546 int
vmaxrep(unsigned char ch,int cnt)1547 vmaxrep(unsigned char ch, int cnt)
1548 {
1549 int len;
1550 unsigned char *cp;
1551 int repcnt, oldcnt, replen;
1552 if (cnt > LBSIZE - 2)
1553 cnt = LBSIZE - 2;
1554 if (ch == 'R') {
1555 len = strlen(cursor);
1556 oldcnt = 0;
1557 for(cp = cursor; *cp; ) {
1558 oldcnt++;
1559 cp = nextchr(cp);
1560 }
1561 repcnt = 0;
1562 for(cp = genbuf; *cp; ) {
1563 repcnt++;
1564 cp = nextchr(cp);
1565 }
1566 /*
1567 * if number of characters in replacement string
1568 * (repcnt) is less than number of characters following
1569 * cursor (oldcnt), find end of repcnt
1570 * characters after cursor
1571 */
1572 if(repcnt < oldcnt) {
1573 for(cp = cursor; repcnt > 0; repcnt--)
1574 cp = nextchr(cp);
1575 len = cp - cursor;
1576 }
1577 CP(cursor, cursor + len);
1578 vUD2 += len;
1579 }
1580 len = strlen(linebuf);
1581 replen = strlen(genbuf);
1582 if (len + cnt * replen <= LBSIZE - 2)
1583 return (cnt);
1584 cnt = (LBSIZE - 2 - len) / replen;
1585 if (cnt == 0) {
1586 vsave();
1587 error(gettext("Line too long"));
1588 }
1589 return (cnt);
1590 }
1591
1592 /*
1593 * Determine how many occurrences of word 'CAP' are in 'MAPTO'. To be
1594 * considered an occurrence there must be both a nonword-prefix, a
1595 * complete match of 'CAP' within 'MAPTO', and a nonword-suffix.
1596 * Note that the beginning and end of 'MAPTO' are considered to be
1597 * valid nonword delimiters.
1598 */
1599 int
reccnt(unsigned char * cap,unsigned char * mapto)1600 reccnt(unsigned char *cap, unsigned char *mapto)
1601 {
1602 int i, cnt, final;
1603
1604 cnt = 0;
1605 final = strlen(mapto) - strlen(cap);
1606
1607 for (i=0; i <= final; i++)
1608 if ((strncmp(cap, mapto+i, strlen(cap)) == 0) /* match */
1609 && (i == 0 || !wordch(&mapto[i-1])) /* prefix ok */
1610 && (i == final || !wordch(&mapto[i+strlen(cap)]))) /* suffix ok */
1611 cnt++;
1612 return (cnt);
1613 }
1614
1615