![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to util.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 util.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: #include "jove.h"
9: #include "ctype.h"
10: #include "termcap.h"
11: #include "disp.h"
12: #include "fp.h"
13: #include <signal.h>
14:
15: #ifdef MAC
16: # include "mac.h"
17: #else
18: # ifdef STDARGS
19: # include <stdarg.h>
20: # else
21: # include <varargs.h>
22: # endif
23: #endif
24:
25: #ifdef MSDOS
26: #include <time.h>
27: #endif
28:
29: const struct cmd *
30: FindCmd(proc)
31: register void (*proc) proto((void));
32: {
33: register const struct cmd *cp;
34:
35: for (cp = commands; cp->Name; cp++)
36: if (cp->c_proc == proc)
37: return cp;
38: return 0;
39: }
40:
41: int Interactive; /* True when we invoke with the command handler? */
42: data_obj *LastCmd;
43: char *ProcFmt = ": %f ";
44:
45: void
46: ExecCmd(cp)
47: register data_obj *cp;
48: {
49: LastCmd = cp;
50: if (cp->Type & MAJOR_MODE) {
51: SetMajor((cp->Type >> 8));
52: } else if (cp->Type & MINOR_MODE) {
53: TogMinor((cp->Type >> 8));
54: } else switch (cp->Type&TYPEMASK) {
55: case MACRO:
56: do_macro((struct macro *) cp);
57: break;
58:
59: case FUNCTION:
60: {
61: register struct cmd *cmd = (struct cmd *) cp;
62:
63: if (cmd->c_proc) {
64: if ((cmd->Type & MODIFIER) &&
65: (BufMinorMode(curbuf, ReadOnly))) {
66: rbell();
67: message("[Buffer is read-only]");
68: } else
69: (*cmd->c_proc)();
70: }
71: }
72: }
73: }
74:
75: Line *
76: lastline(lp)
77: register Line *lp;
78: {
79: register Line *next;
80:
81: while ((next = lp->l_next) != NULL)
82: lp = next;
83: return lp;
84: }
85:
86: char key_strokes[100],
87: *keys_p = key_strokes;
88:
89: void
90: pp_key_strokes(buffer, size)
91: char *buffer;
92: size_t size;
93: {
94: char *buf_end = buffer + size - 5, /* leave some extra space */
95: *kp = key_strokes,
96: c;
97:
98: *buffer = '\0';
99: while ((c = *kp++) != '\0') {
100: swritef(buffer, "%p ", c);
101: buffer += strlen(buffer);
102: if (buffer > buf_end)
103: break;
104: }
105: }
106:
107: private int *slowp = 0; /* for waitchar() */
108:
109: private SIGRESULT
110: slowpoke(junk)
111: int junk;
112: {
113: char buffer[100];
114:
115: if (slowp)
116: *slowp = YES;
117: pp_key_strokes(buffer, sizeof (buffer));
118: f_mess(buffer);
119: SIGRETURN;
120: }
121:
122: #ifdef UNIX
123: # ifdef BSD4_2
124: # define N_SEC 1 /* will be precisely 1 second on 4.2 */
125: # else
126: # define N_SEC 2 /* but from 1 to 2 seconds otherwise */
127: # endif
128: #else /* MSDOS or MAC */
129: # define N_SEC 1
130: int in_macro();
131: #endif /* UNIX */
132:
133: int
134: waitchar(slow)
135: int *slow;
136: {
137: int c;
138: #ifdef UNIX
139: unsigned int old_time;
140: SIGRESULT (*oldproc) proto((int));
141: #else /* MSDOS or MAC */
142: long sw, time();
143: #endif /* UNIX */
144:
145: slowp = slow;
146:
147: if (in_macro()) /* make macros faster ... */
148: return getch();
149:
150: /* If slow is a valid pointer and it's value is yes, then
151: we know we have already been slow during this sequence,
152: so we just wait for the character and then echo it. */
153: if (slow != 0 && *slow == YES) {
154: c = getch();
155: slowpoke(0);
156: return c;
157: }
158: #ifdef UNIX
159: oldproc = signal(SIGALRM, slowpoke);
160:
161: if ((old_time = alarm((unsigned) N_SEC)) == 0)
162: old_time = UpdFreq;
163: c = getch();
164: (void) alarm(old_time);
165: (void) signal(SIGALRM, oldproc);
166:
167: if (slow != 0 && *slow == YES)
168: slowpoke(0);
169: return c;
170:
171: #else /* MSDOS or MAC */
172: #ifdef MAC
173: Keyonly = 1;
174: if (charp() || in_macro()) {
175: c = getch(); /* to avoid flicker */
176: if (slow != 0 && *slow == YES)
177: slowpoke();
178: return c;
179: }
180: #endif
181: time(&sw);
182: sw += N_SEC;
183: while (time(NULL) <= sw)
184: if (charp() || in_macro())
185: return getch();
186: #ifdef MAC
187: menus_off();
188: #endif
189: slowpoke();
190: c = getch();
191: slowpoke();
192:
193: return c;
194: #endif /* UNIX */
195: }
196:
197: /* dir > 0 means forward; else means backward. */
198:
199: char *
200: StrIndex(dir, buf, charpos, what)
201: int dir;
202: register char *buf;
203: int charpos;
204: register int what;
205: {
206: register char *cp = &buf[charpos];
207: register int c;
208:
209: if (dir > 0) {
210: while ((c = *cp++) != '\0')
211: if ((c == what) != '\0')
212: return (cp - 1);
213: } else {
214: while (cp >= buf && (c = *cp--)!='\0')
215: if (c == what)
216: return (cp + 1);
217: }
218: return 0;
219: }
220:
221: int
222: blnkp(buf)
223: register char *buf;
224: {
225: register char c;
226:
227: while ((c = *buf++)!='\0' && (c == ' ' || c == '\t'))
228: ;
229: return c == 0; /* It's zero if we got to the end of the Line */
230: }
231:
232: int
233: within_indent()
234: {
235: register char c;
236: register int i;
237:
238: i = curchar;
239: while (--i >= 0 && ((c = linebuf[i]) == ' ' || c == '\t'))
240: ;
241: return (i < 0); /* it's < 0 if we got to the beginning */
242: }
243:
244: Line *
245: next_line(line, num)
246: register Line *line;
247: register int num;
248: {
249: if (num < 0)
250: return prev_line(line, -num);
251: if (line)
252: while (--num >= 0 && line->l_next != 0)
253: line = line->l_next;
254: return line;
255: }
256:
257: Line *
258: prev_line(line, num)
259: register Line *line;
260: register int num;
261: {
262: if (num < 0)
263: return next_line(line, -num);
264: if (line)
265: while (--num >= 0 && line->l_prev != 0)
266: line = line->l_prev;
267: return line;
268: }
269:
270: void
271: DotTo(line, col)
272: Line *line;
273: int col;
274: {
275: Bufpos bp;
276:
277: bp.p_line = line;
278: bp.p_char = col;
279: SetDot(&bp);
280: }
281:
282: /* If bp->p_line is != current line, then save current line. Then set dot
283: to bp->p_line, and if they weren't equal get that line into linebuf. */
284:
285: void
286: SetDot(bp)
287: register Bufpos *bp;
288: {
289: register int notequal;
290:
291: if (bp == 0)
292: return;
293:
294: notequal = bp->p_line != curline;
295: if (notequal)
296: lsave();
297: if (bp->p_line)
298: curline = bp->p_line;
299: if (notequal)
300: getDOT();
301: curchar = bp->p_char;
302: if (curchar > length(curline))
303: curchar = length(curline);
304: }
305:
306: void
307: ToLast()
308: {
309: SetLine(curbuf->b_last);
310: Eol();
311: }
312:
313: int MarkThresh = 22; /* average screen size ... */
314: static int line_diff;
315:
316: int
317: LineDist(nextp, endp)
318: register Line *nextp,
319: *endp;
320: {
321: (void) inorder(nextp, 0, endp, 0);
322: return line_diff;
323: }
324:
325: int
326: inorder(nextp, char1, endp, char2)
327: register Line *nextp,
328: *endp;
329: int char1,
330: char2;
331: {
332: int count = 0;
333: register Line *prevp = nextp;
334:
335: line_diff = 0;
336: if (nextp == endp)
337: return char1 < char2;
338:
339: while (nextp || prevp) {
340: if (nextp == endp || prevp == endp)
341: break;
342: if (nextp)
343: nextp = nextp->l_next;
344: if (prevp)
345: prevp = prevp->l_prev;
346: count += 1;
347: }
348: if (nextp == 0 && prevp == 0)
349: return -1;
350: line_diff = count;
351:
352: return nextp == endp;
353: }
354:
355: void
356: PushPntp(line)
357: register Line *line;
358: {
359: if (LineDist(curline, line) >= MarkThresh)
360: set_mark();
361: }
362:
363: void
364: ToFirst()
365: {
366: SetLine(curbuf->b_first);
367: }
368:
369: int
370: length(line)
371: Line *line;
372: {
373: return strlen(lcontents(line));
374: }
375:
376: void
377: to_word(dir)
378: register int dir;
379: {
380: register char c;
381:
382: if (dir == FORWARD) {
383: while ((c = linebuf[curchar]) != 0 && !isword(c))
384: curchar += 1;
385: if (eolp()) {
386: if (curline->l_next == 0)
387: return;
388: SetLine(curline->l_next);
389: to_word(dir);
390: return;
391: }
392: } else {
393: while (!bolp() && (c = linebuf[curchar - 1], !isword(c)))
394: curchar -= 1;
395: if (bolp()) {
396: if (curline->l_prev == 0)
397: return;
398: SetLine(curline->l_prev);
399: Eol();
400: to_word(dir);
401: }
402: }
403: }
404:
405: /* Are there any modified buffers? Allp means include B_PROCESS
406: buffers in the check. */
407:
408: int
409: ModBufs(allp)
410: int allp;
411: {
412: register Buffer *b;
413:
414: for (b = world; b != 0; b = b->b_next) {
415: if (b->b_type == B_SCRATCH)
416: continue;
417: if ((b->b_type == B_FILE || allp) && IsModified(b))
418: return 1;
419: }
420: return 0;
421: }
422:
423: char *
424: filename(b)
425: register Buffer *b;
426: {
427: return b->b_fname ? pr_name(b->b_fname, YES) : "[No file]";
428: }
429:
430: char *
431: itoa(num)
432: register int num;
433: {
434: static char line[15];
435:
436: swritef(line, "%d", num);
437: return line;
438: }
439:
440: int
441: min(a, b)
442: register int a,
443: b;
444: {
445: return (a < b) ? a : b;
446: }
447:
448: int
449: max(a, b)
450: register int a,
451: b;
452: {
453: return (a > b) ? a : b;
454: }
455:
456: void
457: tiewind(w, bp)
458: register Window *w;
459: register Buffer *bp;
460: {
461: int not_tied = (w->w_bufp != bp);
462:
463: UpdModLine = YES; /* kludge ... but speeds things up considerably */
464: w->w_line = bp->b_dot;
465: w->w_char = bp->b_char;
466: w->w_bufp = bp;
467: if (not_tied)
468: CalcWind(w); /* ah, this has been missing since the
469: beginning of time! */
470: }
471:
472: char *
473: lcontents(line)
474: register Line *line;
475: {
476: if (line == curline)
477: return linebuf;
478: else
479: return lbptr(line);
480: }
481:
482: char *
483: ltobuf(line, buf)
484: Line *line;
485: char *buf;
486: {
487: if (line == curline) {
488: if (buf != linebuf)
489: strcpy(buf, linebuf);
490: Jr_Len = strlen(linebuf);
491: } else
492: getline(line->l_dline, buf);
493: return buf;
494: }
495:
496: void
497: DOTsave(buf)
498: Bufpos *buf;
499: {
500: buf->p_line = curline;
501: buf->p_char = curchar;
502: }
503:
504: /* Return none-zero if we had to rearrange the order. */
505:
506: int
507: fixorder(line1, char1, line2, char2)
508: register Line **line1,
509: **line2;
510: register int *char1,
511: *char2;
512: {
513: Line *tline;
514: int tchar;
515:
516: if (inorder(*line1, *char1, *line2, *char2))
517: return 0;
518:
519: tline = *line1;
520: tchar = *char1;
521: *line1 = *line2;
522: *char1 = *char2;
523: *line2 = tline;
524: *char2 = tchar;
525:
526: return 1;
527: }
528:
529: int
530: inlist(first, what)
531: register Line *first,
532: *what;
533: {
534: while (first) {
535: if (first == what)
536: return 1;
537: first = first->l_next;
538: }
539: return 0;
540: }
541:
542: /* Make `buf' (un)modified and tell the redisplay code to update the modeline
543: if it will need to be changed. */
544:
545: int ModCount = 0;
546:
547: void
548: modify()
549: {
550: if (!curbuf->b_modified) {
551: UpdModLine = YES;
552: curbuf->b_modified = YES;
553: }
554: DOLsave = YES;
555: if (!Asking)
556: ModCount += 1;
557: }
558:
559: void
560: unmodify()
561: {
562: if (curbuf->b_modified) {
563: UpdModLine = YES;
564: curbuf->b_modified = NO;
565: }
566: }
567:
568: int
569: numcomp(s1, s2)
570: register char *s1,
571: *s2;
572: {
573: register int count = 0;
574:
575: while (*s1 != 0 && *s1++ == *s2++)
576: count += 1;
577: return count;
578: }
579:
580: char *
581: copystr(str)
582: char *str;
583: {
584: char *val;
585:
586: if (str == 0)
587: return 0;
588: val = emalloc((size_t) (strlen(str) + 1));
589:
590: strcpy(val, str);
591: return val;
592: }
593:
594: #ifndef byte_copy
595: void
596: byte_copy(from, to, count)
597: register char *from,
598: *to;
599: register size_t count;
600: {
601: while (count-- > 0)
602: *to++ = *from++;
603: }
604: #endif
605:
606: void
607: len_error(flag)
608: int flag;
609: {
610: char *mesg = "[line too long]";
611:
612: if (flag == COMPLAIN)
613: complain(mesg);
614: else
615: error(mesg);
616: }
617:
618: /* Insert num number of c's at offset atchar in a linebuf of LBSIZE */
619:
620: void
621: ins_c(c, buf, atchar, num, max)
622: int c;
623: char *buf;
624: int atchar,
625: num,
626: max;
627: {
628: register char *pp, *pp1;
629: register int len;
630: int numchars; /* number of characters to copy forward */
631:
632: if (num <= 0)
633: return;
634: len = atchar + strlen(&buf[atchar]);
635: if (len + num >= max)
636: len_error(COMPLAIN);
637: pp = &buf[len + 1]; /* + 1 so we can --pp (not pp--) */
638: pp1 = &buf[len + num + 1];
639: numchars = len - atchar;
640: while (numchars-- >= 0)
641: *--pp1 = *--pp;
642: pp = &buf[atchar];
643: while (--num >= 0)
644: *pp++ = c;
645: }
646:
647: int
648: TwoBlank()
649: {
650: register Line *next = curline->l_next;
651:
652: return ((next != 0) &&
653: (*(lcontents(next)) == '\0') &&
654: (next->l_next != 0) &&
655: (*(lcontents(next->l_next)) == '\0'));
656: }
657:
658: void
659: linecopy(onto, atchar, from)
660: register char *onto,
661: *from;
662: int atchar;
663: {
664: register char *endp = &onto[LBSIZE - 2];
665:
666: onto += atchar;
667:
668: while ((*onto = *from++) != '\0')
669: if (onto++ >= endp)
670: len_error(ERROR);
671: }
672:
673: char *
674: IOerr(err, file)
675: char *err, *file;
676: {
677: return sprint("Couldn't %s \"%s\".", err, file);
678: }
679:
680: #ifdef UNIX
681: void
682: dopipe(p)
683: int *p;
684: {
685: if (pipe(p) == -1)
686: complain("[Pipe failed]");
687: }
688:
689: void
690: pclose(p)
691: int *p;
692: {
693: (void) close(p[0]);
694: (void) close(p[1]);
695: }
696: #endif /* UNIX */
697:
698: /* NOSTRICT */
699:
700: char *
701: emalloc(size)
702: size_t size;
703: {
704: register char *ptr;
705:
706: if ((ptr = malloc(size)) != NULL)
707: return ptr;
708: /* Try garbage collecting lines */
709: GCchunks();
710: if ((ptr = malloc(size)) != NULL)
711: return ptr;
712: /* Uh ... Oh screw it! */
713: error("[Out of memory] ");
714: /* NOTREACHED */
715: }
716:
717: /* Return the basename of file F. */
718:
719: char *
720: basename(f)
721: register char *f;
722: {
723: register char *cp;
724:
725: if ((cp = strrchr(f, '/')) != NULL)
726: return cp + 1;
727: else
728: #ifdef MSDOS
729: if (cp = strrchr(f, '\\'))
730: return cp + 1;
731: else
732: if (cp = strrchr(f, ':'))
733: return cp + 1;
734: #endif /* MSDOS */
735: return f;
736: }
737:
738: void
739: push_env(savejmp)
740: jmp_buf savejmp;
741: {
742: byte_copy((char *) mainjmp, (char *) savejmp, sizeof (jmp_buf));
743: }
744:
745: void
746: pop_env(savejmp)
747: jmp_buf savejmp;
748: {
749: byte_copy((char *) savejmp, (char *) mainjmp, sizeof (jmp_buf));
750: }
751:
752: #ifdef LOAD_AV
753: # if defined(BSD4_2) && !defined(BSD2_10)
754: # if defined(PURDUE_EE) && (defined(vax) || defined(gould))
755:
756: void
757: get_la(dp)
758: double *dp;
759: {
760: *dp = (double) loadav(0) / 100.0;
761: }
762:
763: # else /* !PURDUE_EE || (!vax && !gould) */
764:
765: #ifdef sun
766: # include <sys/param.h>
767: #endif
768: #include <nlist.h>
769:
770: static struct nlist nl[] = {
771: { "_avenrun" },
772: #define X_AVENRUN 0
773: { "" }
774: };
775:
776: void
777: get_la(dp)
778: double *dp;
779: {
780: #ifdef sun
781: long avenrun[3];
782: #else
783: double avenrun[3];
784: #endif
785: static int kmem = 0;
786: extern long lseek proto((int, long, int));
787:
788: if (kmem == -1) {
789: *dp = 4.0; /* So shell commands will say "Chugging" */
790: return;
791: } else if (kmem == 0) {
792: if ((kmem = open("/dev/kmem", 0)) == -1) {
793: f_mess("Can't open kmem for load average.");
794: *dp = 4.0;
795: return;
796: }
797: nlist("/vmunix", nl);
798: }
799: lseek(kmem, (long) nl[X_AVENRUN].n_value, 0);
800: read(kmem, (char *) avenrun, sizeof(avenrun));
801: #ifdef sun
802: *dp = (double) avenrun[0] / FSCALE;
803: #else
804: *dp = avenrun[0];
805: #endif
806: }
807:
808: # endif
809: # else /* !BSD4_2 || BSD2_10 */
810:
811: void
812: get_la(dp)
813: double *dp;
814: {
815: short avg[3];
816:
817: gldav(avg);
818: *dp = (double) avg[0] / 256;
819: }
820:
821: # endif
822: #endif /* LOAD_AV */
823:
824: /* get the time buf, designated by *timep, from FROM to TO. */
825: char *
826: get_time(timep, buf, from, to)
827: time_t *timep;
828: char *buf;
829: int from,
830: to;
831: {
832: time_t now;
833: char *cp;
834: extern char *ctime();
835:
836: if (timep != 0)
837: now = *timep;
838: else
839: (void) time(&now);
840: cp = ctime(&now) + from;
841: #ifndef MSDOS
842: if (to == -1)
843: #else /* MSDOS */
844: if ((to == -1) && (cp[strlen(cp)-1] == '\n'))
845: #endif /* MSDOS */
846: cp[strlen(cp) - 1] = '\0'; /* Get rid of \n */
847: else
848: cp[to - from] = '\0';
849: if (buf) {
850: strcpy(buf, cp);
851: return buf;
852: } else
853: return cp;
854: }
855:
856: int
857: casecmp(s1, s2)
858: register char *s1,
859: *s2;
860: {
861: if (!s1 || !s2)
862: return 1; /* which is not zero ... */
863: while (CharUpcase(*s1) == CharUpcase(*s2++))
864: if (*s1++ == '\0')
865: return 0;
866: return (*s1 - *--s2);
867: }
868:
869: int
870: casencmp(s1, s2, n)
871: register char *s1,
872: *s2;
873: register size_t n;
874: {
875: if (!s1 || !s2)
876: return 1; /* which is not zero ... */
877: for (;;) {
878: if (n == 0)
879: return 0;
880: n--;
881: if (CharUpcase(*s1) != CharUpcase(*s2++))
882: return *s1 - *--s2;
883: if (*s1++ == '\0')
884: return 0;
885: }
886: }
887:
888: void
889: null_ncpy(to, from, n)
890: char *to,
891: *from;
892: size_t n;
893: {
894: (void) strncpy(to, from, n);
895: to[n] = '\0';
896: }
897:
898: /* Tries to pause for delay/10 seconds OR until a character is typed
899: at the keyboard. This works well on BSD4_2 and not so well on the
900: rest. Returns 1 if it returned because of keyboard input, or 0
901: otherwise. */
902:
903: #ifdef MAC
904: void
905: SitFor(delay)
906: int delay;
907: {
908: long start,
909: end;
910:
911: #define Ticks ((long *) 0x16A) /* 1/60 sec */
912: Keyonly = 1;
913: redisplay();
914: start = *Ticks;
915:
916: end = start + delay * 6;
917: do
918: if (InputPending = charp())
919: break;
920: while (*Ticks < end);
921: #undef Ticks
922: }
923: #else /* not MAC */
924:
925: #ifndef MSDOS
926: #if defined(BSD4_2) && !defined(BSD2_10)
927: #include <sys/time.h>
928: #endif
929: #endif
930:
931: void
932: SitFor(delay)
933: int delay;
934: {
935: #ifndef MSDOS
936: #if defined(BSD4_2) && !defined(BSD2_10)
937: struct timeval timer;
938: long readfds = 1;
939:
940: timer.tv_sec = (delay / 10);
941: timer.tv_usec = (delay % 10) * 100000;
942:
943: if (charp())
944: return;
945: /* gross that I had to snarf this from getch() */
946: if (!UpdMesg && !Asking) { /* Don't erase if we are asking */
947: if (mesgbuf[0] && !errormsg)
948: message(NullStr);
949: }
950: redisplay();
951: select(1, &readfds, (long *)0, (long *)0, &timer);
952: #else
953: static const int cps[] = {
954: 0,
955: 5,
956: 7,
957: 11,
958: 13,
959: 15,
960: 20,
961: 30,
962: 60,
963: 120,
964: 180,
965: 240,
966: 480,
967: 960,
968: 1920,
969: 1920,
970: };
971: register int nchars,
972: check_cnt;
973:
974: if (charp())
975: return;
976: nchars = (delay * cps[ospeed]) / 10;
977: check_cnt = BufSize;
978: redisplay();
979: while ((--nchars > 0) && !InputPending) {
980: jputchar(0);
981: if (--check_cnt == 0) {
982: check_cnt = BufSize;
983: InputPending = charp();
984: }
985: }
986: #endif
987: #else /* MSDOS */
988: #include <bios.h>
989: #include <dos.h>
990:
991: long start,
992: end;
993: #ifndef IBMPC
994: struct dostime_t tc;
995: #endif
996:
997: redisplay();
998: #ifdef IBMPC
999: _bios_timeofday(_TIME_GETCLOCK, &start);
1000: #else
1001: _dos_gettime(&tc);
1002: start = (long)(tc.hour*60L*60L*10L)+(long)(tc.minute*60L*10L)+
1003: (long)(tc.second*10)+(long)(tc.hsecond/10);
1004: #endif
1005: end = (start + delay);
1006: do {
1007: if (InputPending = charp())
1008: break;
1009: #ifdef IBMPC
1010: if (_bios_timeofday(_TIME_GETCLOCK, &start))
1011: break; /* after midnight */
1012: #else
1013: start = (long)(tc.hour*60L*60L*10L)+(long)(tc.minute*60L*10L)+
1014: (long)(tc.second*10)+(long)(tc.hsecond/10);
1015: #endif
1016: }
1017: while (start < end);
1018: #endif /* MSDOS */
1019: }
1020: #endif /* MAC */
1021:
1022: int
1023: sindex(pattern, string)
1024: register char *pattern,
1025: *string;
1026: {
1027: register size_t len = strlen(pattern);
1028:
1029: while (*string != '\0') {
1030: if (*pattern == *string && strncmp(pattern, string, len) == 0)
1031: return TRUE;
1032: string += 1;
1033: }
1034: return FALSE;
1035: }
1036:
1037: void
1038: make_argv(argv, ap)
1039: register char *argv[];
1040: va_list ap;
1041: {
1042: register char *cp;
1043: register int i = 0;
1044:
1045: argv[i++] = va_arg(ap, char *);
1046: argv[i++] = basename(argv[0]);
1047: while ((cp = va_arg(ap, char *)) != NULL)
1048: argv[i++] = cp;
1049: argv[i] = 0;
1050: }
1051:
1052: int
1053: pnt_line()
1054: {
1055: register Line *lp = curbuf->b_first;
1056: register int i;
1057:
1058: for (i = 0; lp != 0; i++, lp = lp->l_next)
1059: if (lp == curline)
1060: break;
1061: return i + 1;
1062: }
1063:
1064: char *
1065: ralloc(obj, size)
1066: register char *obj;
1067: size_t size;
1068: {
1069: register char *new;
1070:
1071: if (obj)
1072: new = realloc(obj, size);
1073: if (new == 0 || !obj)
1074: new = emalloc(size);
1075: return new;
1076: }
1077:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.