![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_vops2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / cmd / ex|
Return to ex_vops2.c CVS log | Up to [Research Unix] / researchv10dc / cmd / ex |
1.1 root 1: /* Copyright (c) 1981 Regents of the University of California */
2: static char *sccsid = "@(#)ex_vops2.c 6.5 7/26/81";
3: #include "ex.h"
4: #include "ex_tty.h"
5: #include "ex_vis.h"
6:
7: /*
8: * Low level routines for operations sequences,
9: * and mostly, insert mode (and a subroutine
10: * to read an input line, including in the echo area.)
11: */
12: extern char *vUA1, *vUA2; /* mjm: extern; also in ex_vops.c */
13: extern char *vUD1, *vUD2; /* mjm: extern; also in ex_vops.c */
14:
15: /*
16: * Obleeperate characters in hardcopy
17: * open with \'s.
18: */
19: bleep(i, cp)
20: register int i;
21: char *cp;
22: {
23:
24: i -= column(cp);
25: do
26: putchar('\\' | QUOTE);
27: while (--i >= 0);
28: rubble = 1;
29: }
30:
31: /*
32: * Common code for middle part of delete
33: * and change operating on parts of lines.
34: */
35: vdcMID()
36: {
37: register char *cp;
38:
39: squish();
40: setLAST();
41: if (FIXUNDO)
42: vundkind = VCHNG, CP(vutmp, linebuf);
43: if (wcursor < cursor)
44: cp = wcursor, wcursor = cursor, cursor = cp;
45: vUD1 = vUA1 = vUA2 = cursor; vUD2 = wcursor;
46: return (column(wcursor - 1));
47: }
48:
49: /*
50: * Take text from linebuf and stick it
51: * in the VBSIZE buffer BUF. Used to save
52: * deleted text of part of line.
53: */
54: takeout(BUF)
55: char *BUF;
56: {
57: register char *cp;
58:
59: if (wcursor < linebuf)
60: wcursor = linebuf;
61: if (cursor == wcursor) {
62: beep();
63: return;
64: }
65: if (wcursor < cursor) {
66: cp = wcursor;
67: wcursor = cursor;
68: cursor = cp;
69: }
70: setBUF(BUF);
71: if ((BUF[0] & (QUOTE|TRIM)) == OVERBUF)
72: beep();
73: }
74:
75: /*
76: * Are we at the end of the printed representation of the
77: * line? Used internally in hardcopy open.
78: */
79: ateopr()
80: {
81: register int i, c;
82: register char *cp = vtube[destline] + destcol;
83:
84: for (i = WCOLS - destcol; i > 0; i--) {
85: c = *cp++;
86: if (c == 0)
87: return (1);
88: if (c != ' ' && (c & QUOTE) == 0)
89: return (0);
90: }
91: return (1);
92: }
93:
94: /*
95: * Append.
96: *
97: * This routine handles the top level append, doing work
98: * as each new line comes in, and arranging repeatability.
99: * It also handles append with repeat counts, and calculation
100: * of autoindents for new lines.
101: */
102: bool vaifirst;
103: bool gobbled;
104: char *ogcursor;
105:
106: vappend(ch, cnt, indent)
107: int ch; /* mjm: char --> int */
108: int cnt, indent;
109: {
110: register int i;
111: register char *gcursor;
112: bool escape;
113: int repcnt, savedoomed;
114: short oldhold = hold;
115:
116: /*
117: * Before a move in hardopen when the line is dirty
118: * or we are in the middle of the printed representation,
119: * we retype the line to the left of the cursor so the
120: * insert looks clean.
121: */
122: if (ch != 'o' && state == HARDOPEN && (rubble || !ateopr())) {
123: rubble = 1;
124: gcursor = cursor;
125: i = *gcursor;
126: *gcursor = ' ';
127: wcursor = gcursor;
128: vmove();
129: *gcursor = i;
130: }
131: vaifirst = indent == 0;
132:
133: /*
134: * Handle replace character by (eventually)
135: * limiting the number of input characters allowed
136: * in the vgetline routine.
137: */
138: if (ch == 'r')
139: repcnt = 2;
140: else
141: repcnt = 0;
142:
143: /*
144: * If an autoindent is specified, then
145: * generate a mixture of blanks to tabs to implement
146: * it and place the cursor after the indent.
147: * Text read by the vgetline routine will be placed in genbuf,
148: * so the indent is generated there.
149: */
150: if (value(AUTOINDENT) && indent != 0) {
151: gcursor = genindent(indent);
152: *gcursor = 0;
153: vgotoCL(qcolumn(cursor - 1, genbuf));
154: } else {
155: gcursor = genbuf;
156: *gcursor = 0;
157: if (ch == 'o')
158: vfixcurs();
159: }
160:
161: /*
162: * Prepare for undo. Pointers delimit inserted portion of line.
163: */
164: vUA1 = vUA2 = cursor;
165:
166: /*
167: * If we are not in a repeated command and a ^@ comes in
168: * then this means the previous inserted text.
169: * If there is none or it was too long to be saved,
170: * then beep() and also arrange to undo any damage done
171: * so far (e.g. if we are a change.)
172: */
173: if ((vglobp && *vglobp == 0) || peekbr()) {
174: if ((INS[0] & (QUOTE|TRIM)) == OVERBUF) {
175: beep();
176: if (!splitw)
177: ungetkey('u');
178: doomed = 0;
179: hold = oldhold;
180: return;
181: }
182: /*
183: * Unread input from INS.
184: * An escape will be generated at end of string.
185: * Hold off n^^2 type update on dumb terminals.
186: */
187: vglobp = INS;
188: hold |= HOLDQIK;
189: } else if (vglobp == 0)
190: /*
191: * Not a repeated command, get
192: * a new inserted text for repeat.
193: */
194: INS[0] = 0;
195:
196: /*
197: * For wrapmargin to hack away second space after a '.'
198: * when the first space caused a line break we keep
199: * track that this happened in gobblebl, which says
200: * to gobble up a blank silently.
201: */
202: gobblebl = 0;
203:
204: /*
205: * Text gathering loop.
206: * New text goes into genbuf starting at gcursor.
207: * cursor preserves place in linebuf where text will eventually go.
208: */
209: if (*cursor == 0 || state == CRTOPEN)
210: hold |= HOLDROL;
211: for (;;) {
212: if (ch == 'r' && repcnt == 0)
213: escape = 0;
214: else {
215: gcursor = vgetline(repcnt, gcursor, &escape, ch);
216:
217: /*
218: * After an append, stick information
219: * about the ^D's and ^^D's and 0^D's in
220: * the repeated text buffer so repeated
221: * inserts of stuff indented with ^D as backtab's
222: * can work.
223: */
224: if (HADUP)
225: addtext("^");
226: else if (HADZERO)
227: addtext("0");
228: while (CDCNT > 0)
229: addtext("\204"), CDCNT--;
230: if (gobbled)
231: addtext(" ");
232: addtext(ogcursor);
233: }
234: repcnt = 0;
235:
236: /*
237: * Smash the generated and preexisting indents together
238: * and generate one cleanly made out of tabs and spaces
239: * if we are using autoindent.
240: */
241: if (!vaifirst && value(AUTOINDENT)) {
242: i = fixindent(indent);
243: if (!HADUP)
244: indent = i;
245: gcursor = strend(genbuf);
246: }
247:
248: /*
249: * Limit the repetition count based on maximum
250: * possible line length; do output implied
251: * by further count (> 1) and cons up the new line
252: * in linebuf.
253: */
254: cnt = vmaxrep(ch, cnt);
255: CP(gcursor + 1, cursor);
256: do {
257: CP(cursor, genbuf);
258: if (cnt > 1) {
259: int oldhold = hold;
260:
261: Outchar = vinschar;
262: hold |= HOLDQIK;
263: printf("%s", genbuf);
264: hold = oldhold;
265: Outchar = vputchar;
266: }
267: cursor += gcursor - genbuf;
268: } while (--cnt > 0);
269: endim();
270: vUA2 = cursor;
271: if (escape != '\n')
272: CP(cursor, gcursor + 1);
273:
274: /*
275: * If doomed characters remain, clobber them,
276: * and reopen the line to get the display exact.
277: */
278: if (state != HARDOPEN) {
279: DEPTH(vcline) = 0;
280: savedoomed = doomed;
281: if (doomed > 0) {
282: register int cind = cindent();
283:
284: physdc(cind, cind + doomed);
285: doomed = 0;
286: }
287: i = vreopen(LINE(vcline), lineDOT(), vcline);
288: #ifdef TRACE
289: if (trace)
290: fprintf(trace, "restoring doomed from %d to %d\n", doomed, savedoomed);
291: #endif
292: if (ch == 'R')
293: doomed = savedoomed;
294: }
295:
296: /*
297: * All done unless we are continuing on to another line.
298: */
299: if (escape != '\n')
300: break;
301:
302: /*
303: * Set up for the new line.
304: * First save the current line, then construct a new
305: * first image for the continuation line consisting
306: * of any new autoindent plus the pushed ahead text.
307: */
308: killU();
309: addtext(gobblebl ? " " : "\n");
310: vsave();
311: cnt = 1;
312: if (value(AUTOINDENT)) {
313: #ifdef LISPCODE
314: if (value(LISP))
315: indent = lindent(dot + 1);
316: else
317: #endif
318: if (!HADUP && vaifirst)
319: indent = whitecnt(linebuf);
320: vaifirst = 0;
321: strcLIN(vpastwh(gcursor + 1));
322: gcursor = genindent(indent);
323: *gcursor = 0;
324: if (gcursor + strlen(linebuf) > &genbuf[LBSIZE - 2])
325: gcursor = genbuf;
326: CP(gcursor, linebuf);
327: } else {
328: CP(genbuf, gcursor + 1);
329: gcursor = genbuf;
330: }
331:
332: /*
333: * If we started out as a single line operation and are now
334: * turning into a multi-line change, then we had better yank
335: * out dot before it changes so that undo will work
336: * correctly later.
337: */
338: if (FIXUNDO && vundkind == VCHNG) {
339: vremote(1, yank, 0);
340: undap1--;
341: }
342:
343: /*
344: * Now do the append of the new line in the buffer,
345: * and update the display. If slowopen
346: * we don't do very much.
347: */
348: vdoappend(genbuf);
349: vundkind = VMANYINS;
350: vcline++;
351: if (state != VISUAL)
352: vshow(dot, NOLINE);
353: else {
354: i += LINE(vcline - 1);
355: vopen(dot, i);
356: if (value(SLOWOPEN))
357: vscrap();
358: else
359: vsync1(LINE(vcline));
360: }
361: strcLIN(gcursor);
362: *gcursor = 0;
363: cursor = linebuf;
364: vgotoCL(qcolumn(cursor - 1, genbuf));
365: }
366:
367: /*
368: * All done with insertion, position the cursor
369: * and sync the screen.
370: */
371: hold = oldhold;
372: if (cursor > linebuf)
373: cursor--;
374: if (state != HARDOPEN)
375: vsyncCL();
376: else if (cursor > linebuf)
377: back1();
378: doomed = 0;
379: wcursor = cursor;
380: vmove();
381: }
382:
383: /*
384: * Subroutine for vgetline to back up a single character position,
385: * backwards around end of lines (vgoto can't hack columns which are
386: * less than 0 in general).
387: */
388: back1()
389: {
390:
391: vgoto(destline - 1, WCOLS + destcol - 1);
392: }
393:
394: /*
395: * Get a line into genbuf after gcursor.
396: * Cnt limits the number of input characters
397: * accepted and is used for handling the replace
398: * single character command. Aescaped is the location
399: * where we stick a termination indicator (whether we
400: * ended with an ESCAPE or a newline/return.
401: *
402: * We do erase-kill type processing here and also
403: * are careful about the way we do this so that it is
404: * repeatable. (I.e. so that your kill doesn't happen,
405: * when you repeat an insert if it was escaped with \ the
406: * first time you did it. commch is the command character
407: * involved, including the prompt for readline.
408: */
409: char *
410: vgetline(cnt, gcursor, aescaped, commch)
411: int cnt;
412: register char *gcursor;
413: bool *aescaped;
414: char commch;
415: {
416: register int c, ch;
417: register char *cp;
418: int x, y, iwhite, backsl=0;
419: char *iglobp;
420: char cstr[2];
421: int (*OO)() = Outchar;
422:
423: /*
424: * Clear the output state and counters
425: * for autoindent backwards motion (counts of ^D, etc.)
426: * Remember how much white space at beginning of line so
427: * as not to allow backspace over autoindent.
428: */
429: *aescaped = 0;
430: ogcursor = gcursor;
431: flusho();
432: CDCNT = 0;
433: HADUP = 0;
434: HADZERO = 0;
435: gobbled = 0;
436: iwhite = whitecnt(genbuf);
437: iglobp = vglobp;
438:
439: /*
440: * Carefully avoid using vinschar in the echo area.
441: */
442: if (splitw)
443: Outchar = vputchar;
444: else {
445: Outchar = vinschar;
446: vprepins();
447: }
448: for (;;) {
449: backsl = 0;
450: if (gobblebl)
451: gobblebl--;
452: if (cnt != 0) {
453: cnt--;
454: if (cnt == 0)
455: goto vadone;
456: }
457: c = getkey();
458: if (c != ATTN)
459: c &= (QUOTE|TRIM);
460: ch = c;
461: maphopcnt = 0;
462: if (vglobp == 0 && Peekkey == 0 && commch != 'r')
463: while ((ch = map(c, immacs)) != c) {
464: c = ch;
465: if (!value(REMAP))
466: break;
467: if (++maphopcnt > 256)
468: error("Infinite macro loop");
469: }
470: if (!iglobp) {
471:
472: /*
473: * Erase-kill type processing.
474: * Only happens if we were not reading
475: * from untyped input when we started.
476: * Map users erase to ^H, kill to -1 for switch.
477: */
478: #ifndef USG3TTY
479: if (c == tty.sg_erase)
480: c = CTRL(h);
481: else if (c == tty.sg_kill)
482: c = -1;
483: #else
484: if (c == tty.c_cc[VERASE])
485: c = CTRL(h);
486: else if (c == tty.c_cc[VKILL])
487: c = -1;
488: #endif
489: switch (c) {
490:
491: /*
492: * ^? Interrupt drops you back to visual
493: * command mode with an unread interrupt
494: * still in the input buffer.
495: *
496: * ^\ Quit does the same as interrupt.
497: * If you are a ex command rather than
498: * a vi command this will drop you
499: * back to command mode for sure.
500: */
501: case ATTN:
502: case QUIT:
503: ungetkey(c);
504: goto vadone;
505:
506: /*
507: * ^H Backs up a character in the input.
508: *
509: * BUG: Can't back around line boundaries.
510: * This is hard because stuff has
511: * already been saved for repeat.
512: */
513: case CTRL(h):
514: bakchar:
515: cp = gcursor - 1;
516: if (cp < ogcursor) {
517: if (splitw) {
518: /*
519: * Backspacing over readecho
520: * prompt. Pretend delete but
521: * don't beep.
522: */
523: ungetkey(c);
524: goto vadone;
525: }
526: beep();
527: continue;
528: }
529: goto vbackup;
530:
531: /*
532: * ^W Back up a white/non-white word.
533: */
534: case CTRL(w):
535: wdkind = 1;
536: for (cp = gcursor; cp > ogcursor && isspace(cp[-1]); cp--)
537: continue;
538: for (c = wordch(cp - 1);
539: cp > ogcursor && wordof(c, cp - 1); cp--)
540: continue;
541: goto vbackup;
542:
543: /*
544: * users kill Kill input on this line, back to
545: * the autoindent.
546: */
547: case -1:
548: cp = ogcursor;
549: vbackup:
550: if (cp == gcursor) {
551: beep();
552: continue;
553: }
554: endim();
555: *cp = 0;
556: c = cindent();
557: vgotoCL(qcolumn(cursor - 1, genbuf));
558: if (doomed >= 0)
559: doomed += c - cindent();
560: gcursor = cp;
561: continue;
562:
563: /*
564: * \ Followed by erase or kill
565: * maps to just the erase or kill.
566: */
567: case '\\':
568: x = destcol, y = destline;
569: putchar('\\');
570: vcsync();
571: c = getkey();
572: #ifndef USG3TTY
573: if (c == tty.sg_erase || c == tty.sg_kill)
574: #else
575: if (c == tty.c_cc[VERASE]
576: || c == tty.c_cc[VKILL])
577: #endif
578: {
579: vgoto(y, x);
580: if (doomed >= 0)
581: doomed++;
582: goto def;
583: }
584: ungetkey(c), c = '\\';
585: backsl = 1;
586: break;
587:
588: /*
589: * ^Q Super quote following character
590: * Only ^@ is verboten (trapped at
591: * a lower level) and \n forces a line
592: * split so doesn't really go in.
593: *
594: * ^V Synonym for ^Q
595: */
596: case CTRL(q):
597: case CTRL(v):
598: x = destcol, y = destline;
599: putchar('^');
600: vgoto(y, x);
601: c = getkey();
602: #ifdef TIOCSETC
603: if (c == ATTN)
604: c = nttyc.t_intrc;
605: #endif
606: if (c != NL) {
607: if (doomed >= 0)
608: doomed++;
609: goto def;
610: }
611: break;
612: }
613: }
614:
615: /*
616: * If we get a blank not in the echo area
617: * consider splitting the window in the wrapmargin.
618: */
619: if (c != NL && !splitw) {
620: if (c == ' ' && gobblebl) {
621: gobbled = 1;
622: continue;
623: }
624: if (value(WRAPMARGIN) &&
625: (outcol >= OCOLUMNS - value(WRAPMARGIN) ||
626: backsl && outcol==0) &&
627: commch != 'r') {
628: /*
629: * At end of word and hit wrapmargin.
630: * Move the word to next line and keep going.
631: */
632: wdkind = 1;
633: *gcursor++ = c;
634: if (backsl)
635: *gcursor++ = getkey();
636: *gcursor = 0;
637: /*
638: * Find end of previous word if we are past it.
639: */
640: for (cp=gcursor; cp>ogcursor && isspace(cp[-1]); cp--)
641: ;
642: if (outcol+(backsl?OCOLUMNS:0) - (gcursor-cp) >= OCOLUMNS - value(WRAPMARGIN)) {
643: /*
644: * Find beginning of previous word.
645: */
646: for (; cp>ogcursor && !isspace(cp[-1]); cp--)
647: ;
648: if (cp <= ogcursor) {
649: /*
650: * There is a single word that
651: * is too long to fit. Just
652: * let it pass, but beep for
653: * each new letter to warn
654: * the luser.
655: */
656: c = *--gcursor;
657: *gcursor = 0;
658: beep();
659: goto dontbreak;
660: }
661: /*
662: * Save it for next line.
663: */
664: macpush(cp, 0);
665: cp--;
666: }
667: macpush("\n", 0);
668: /*
669: * Erase white space before the word.
670: */
671: while (cp > ogcursor && isspace(cp[-1]))
672: cp--; /* skip blank */
673: gobblebl = 3;
674: goto vbackup;
675: }
676: dontbreak:;
677: }
678:
679: /*
680: * Word abbreviation mode.
681: */
682: cstr[0] = c;
683: if (anyabbrs && gcursor > ogcursor && !wordch(cstr) && wordch(gcursor-1)) {
684: int wdtype, abno;
685:
686: cstr[1] = 0;
687: wdkind = 1;
688: cp = gcursor - 1;
689: for (wdtype = wordch(cp - 1);
690: cp > ogcursor && wordof(wdtype, cp - 1); cp--)
691: ;
692: *gcursor = 0;
693: for (abno=0; abbrevs[abno].mapto; abno++) {
694: if (eq(cp, abbrevs[abno].cap)) {
695: macpush(cstr, 0);
696: macpush(abbrevs[abno].mapto);
697: goto vbackup;
698: }
699: }
700: }
701:
702: switch (c) {
703:
704: /*
705: * ^M Except in repeat maps to \n.
706: */
707: case CR:
708: if (vglobp)
709: goto def;
710: c = '\n';
711: /* presto chango ... */
712:
713: /*
714: * \n Start new line.
715: */
716: case NL:
717: *aescaped = c;
718: goto vadone;
719:
720: /*
721: * escape End insert unless repeat and more to repeat.
722: */
723: case ESCAPE:
724: if (lastvgk)
725: goto def;
726: goto vadone;
727:
728: /*
729: * ^D Backtab.
730: * ^T Software forward tab.
731: *
732: * Unless in repeat where this means these
733: * were superquoted in.
734: */
735: case CTRL(d):
736: case CTRL(t):
737: if (vglobp)
738: goto def;
739: /* fall into ... */
740:
741: /*
742: * ^D|QUOTE Is a backtab (in a repeated command).
743: */
744: case CTRL(d) | QUOTE:
745: *gcursor = 0;
746: cp = vpastwh(genbuf);
747: c = whitecnt(genbuf);
748: if (ch == CTRL(t)) {
749: /*
750: * ^t just generates new indent replacing
751: * current white space rounded up to soft
752: * tab stop increment.
753: */
754: if (cp != gcursor)
755: /*
756: * BUG: Don't hack ^T except
757: * right after initial
758: * white space.
759: */
760: continue;
761: cp = genindent(iwhite = backtab(c + value(SHIFTWIDTH) + 1));
762: ogcursor = cp;
763: goto vbackup;
764: }
765: /*
766: * ^D works only if we are at the (end of) the
767: * generated autoindent. We count the ^D for repeat
768: * purposes.
769: */
770: if (c == iwhite && c != 0)
771: if (cp == gcursor) {
772: iwhite = backtab(c);
773: CDCNT++;
774: ogcursor = cp = genindent(iwhite);
775: goto vbackup;
776: } else if (&cp[1] == gcursor &&
777: (*cp == '^' || *cp == '0')) {
778: /*
779: * ^^D moves to margin, then back
780: * to current indent on next line.
781: *
782: * 0^D moves to margin and then
783: * stays there.
784: */
785: HADZERO = *cp == '0';
786: ogcursor = cp = genbuf;
787: HADUP = 1 - HADZERO;
788: CDCNT = 1;
789: endim();
790: back1();
791: vputchar(' ');
792: goto vbackup;
793: }
794: if (vglobp && vglobp - iglobp >= 2 &&
795: (vglobp[-2] == '^' || vglobp[-2] == '0')
796: && gcursor == ogcursor + 1)
797: goto bakchar;
798: continue;
799:
800: default:
801: /*
802: * Possibly discard control inputs.
803: */
804: if (!vglobp && junk(c)) {
805: beep();
806: continue;
807: }
808: def:
809: if (!backsl) {
810: int cnt;
811: putchar(c);
812: flush();
813: }
814: if (gcursor > &genbuf[LBSIZE - 2])
815: error("Line too long");
816: *gcursor++ = c & TRIM;
817: vcsync();
818: if (value(SHOWMATCH) && !iglobp)
819: if (c == ')' || c == '}')
820: lsmatch(gcursor);
821: continue;
822: }
823: }
824: vadone:
825: *gcursor = 0;
826: if (Outchar != termchar)
827: Outchar = OO;
828: endim();
829: return (gcursor);
830: }
831:
832: int vgetsplit();
833: char *vsplitpt;
834:
835: /*
836: * Append the line in buffer at lp
837: * to the buffer after dot.
838: */
839: vdoappend(lp)
840: char *lp;
841: {
842: register int oing = inglobal;
843:
844: vsplitpt = lp;
845: inglobal = 1;
846: ignore(append(vgetsplit, dot));
847: inglobal = oing;
848: }
849:
850: /*
851: * Subroutine for vdoappend to pass to append.
852: */
853: vgetsplit()
854: {
855:
856: if (vsplitpt == 0)
857: return (EOF);
858: strcLIN(vsplitpt);
859: vsplitpt = 0;
860: return (0);
861: }
862:
863: /*
864: * Vmaxrep determines the maximum repetitition factor
865: * allowed that will yield total line length less than
866: * LBSIZE characters and also does hacks for the R command.
867: */
868: vmaxrep(ch, cnt)
869: char ch;
870: register int cnt;
871: {
872: register int len, replen;
873:
874: if (cnt > LBSIZE - 2)
875: cnt = LBSIZE - 2;
876: replen = strlen(genbuf);
877: if (ch == 'R') {
878: len = strlen(cursor);
879: if (replen < len)
880: len = replen;
881: CP(cursor, cursor + len);
882: vUD2 += len;
883: }
884: len = strlen(linebuf);
885: if (len + cnt * replen <= LBSIZE - 2)
886: return (cnt);
887: cnt = (LBSIZE - 2 - len) / replen;
888: if (cnt == 0) {
889: vsave();
890: error("Line too long");
891: }
892: return (cnt);
893: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.