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