![[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.