![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to m_getfld.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / mh / sbr|
Return to m_getfld.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / mh / sbr |
1.1 ! root 1: /* m_getfld.c - read/parse a message */ ! 2: ! 3: #include "../h/mh.h" ! 4: #include <stdio.h> ! 5: #include "../zotnet/mts.h" ! 6: #include <ctype.h> ! 7: ! 8: ! 9: /* This module has a long and checkered history. First, it didn't burst ! 10: maildrops correctly because it considered two CTRL-A:s in a row to be ! 11: an inter-message delimiter. It really is four CTRL-A:s followed by a ! 12: newline. Unfortunately, MMDF will convert this delimiter *inside* a ! 13: message to a CTRL-B followed by three CTRL-A:s and a newline. This ! 14: caused the old version of m_getfld() to declare eom prematurely. The ! 15: fix was a lot slower than ! 16: ! 17: c == '\001' && peekc (iob) == '\001' ! 18: ! 19: but it worked, and to increase generality, UUCP style maildrops could ! 20: be parsed as well. Unfortunately the speed issue finally caught up with ! 21: us since this routine is at the very heart of MH. ! 22: ! 23: To speed things up considerably, the routine Eom() was made an auxilary ! 24: function called by the macro eom(). Unless we are bursting a maildrop, ! 25: the eom() macro returns FALSE saying we aren't at the end of the ! 26: message. ! 27: ! 28: The next thing to do is to read the mtstailor file and initialize ! 29: delimiter[] and delimlen accordingly... ! 30: ! 31: After mhl was made a built-in in msh, m_getfld() worked just fine ! 32: (using m_unknown() at startup). Until one day: a message which was ! 33: the result of a bursting was shown. Then, since the burst boundaries ! 34: aren't CTRL-A:s, m_getfld() would blinding plunge on past the boundary. ! 35: Very sad. The solution: introduce m_eomsbr(). This hook gets called ! 36: after the end of each line (since testing for eom involves an fseek()). ! 37: This worked fine, until one day: a message with no body portion arrived. ! 38: Then the ! 39: ! 40: while (eom (c = Getc (iob), iob)) ! 41: continue; ! 42: ! 43: loop caused m_getfld() to return FMTERR. So, that logic was changed to ! 44: check for (*eom_action) and act accordingly. ! 45: ! 46: This worked fine, until one day: someone didn't use four CTRL:A's as ! 47: their delimiters. So, the bullet got bit and we read mts.h and ! 48: continue to struggle on. It's not that bad though, since the only time ! 49: the code gets executed is when inc (or msh) calls it, and both of these ! 50: have already called mts_init(). ! 51: ! 52: ------------------------ ! 53: (Written by Van Jacobson for the mh6 m_getfld, January, 1986): ! 54: ! 55: This routine was accounting for 60% of the cpu time used by most mh ! 56: programs. I spent a bit of time tuning and it now accounts for <10% ! 57: of the time used. Like any heavily tuned routine, it's a bit ! 58: complex and you want to be sure you understand everything that it's ! 59: doing before you start hacking on it. Let me try to emphasize ! 60: that: every line in this atrocity depends on every other line, ! 61: sometimes in subtle ways. You should understand it all, in detail, ! 62: before trying to change any part. If you do change it, test the ! 63: result thoroughly (I use a hand-constructed test file that exercises ! 64: all the ways a header name, header body, header continuation, ! 65: header-body separator, body line and body eom can align themselves ! 66: with respect to a buffer boundary). "Minor" bugs in this routine ! 67: result in garbaged or lost mail. ! 68: ! 69: If you hack on this and slow it down, I, my children and my ! 70: children's children will curse you. ! 71: ! 72: This routine gets used on three different types of files: normal, ! 73: single msg files, "packed" unix or mmdf mailboxs (when used by inc) ! 74: and packed, directoried bulletin board files (when used by msh). ! 75: The biggest impact of different file types is in "eom" testing. The ! 76: code has been carefully organized to test for eom at appropriate ! 77: times and at no other times (since the check is quite expensive). ! 78: I have tried to arrange things so that the eom check need only be ! 79: done on entry to this routine. Since an eom can only occur after a ! 80: newline, this is easy to manage for header fields. For the msg ! 81: body, we try to efficiently search the input buffer to see if ! 82: contains the eom delimiter. If it does, we take up to the ! 83: delimiter, otherwise we take everything in the buffer. (The change ! 84: to the body eom/copy processing produced the most noticeable ! 85: performance difference, particularly for "inc" and "show".) ! 86: ! 87: There are three qualitatively different things this routine busts ! 88: out of a message: field names, field text and msg bodies. Field ! 89: names are typically short (~8 char) and the loop that extracts them ! 90: might terminate on a colon, newline or max width. I considered ! 91: using a Vax "scanc" to locate the end of the field followed by a ! 92: "bcopy" but the routine call overhead on a Vax is too large for this ! 93: to work on short names. If Berkeley ever makes "inline" part of the ! 94: C optimiser (so things like "scanc" turn into inline instructions) a ! 95: change here would be worthwhile. ! 96: ! 97: Field text is typically 60 - 100 characters so there's (barely) ! 98: a win in doing a routine call to something that does a "locc" ! 99: followed by a "bmove". About 30% of the fields have continuations ! 100: (usually the 822 "received:" lines) and each continuation generates ! 101: another routine call. "Inline" would be a big win here, as well. ! 102: ! 103: Messages, as of this writing, seem to come in two flavors: small ! 104: (~1K) and long (>2K). Most messages have 400 - 600 bytes of headers ! 105: so message bodies average at least a few hundred characters. ! 106: Assuming your system uses reasonably sized stdio buffers (1K or ! 107: more), this routine should be able to remove the body in large ! 108: (>500 byte) chunks. The makes the cost of a call to "bcopy" ! 109: small but there is a premium on checking for the eom in packed ! 110: maildrops. The eom pattern is always a simple string so we can ! 111: construct an efficient pattern matcher for it (e.g., a Vax "matchc" ! 112: instruction). Some thought went into recognizing the start of ! 113: an eom that has been split across two buffers. ! 114: ! 115: This routine wants to deal with large chunks of data so, rather ! 116: than "getc" into a local buffer, it uses stdio's buffer. If ! 117: you try to use it on a non-buffered file, you'll get what you ! 118: deserve. This routine "knows" that struct FILEs have a _ptr ! 119: and a _cnt to describe the current state of the buffer and ! 120: it knows that _filbuf ignores the _ptr & _cnt and simply fills ! 121: the buffer. If stdio on your system doesn't work this way, you ! 122: may have to make small changes in this routine. ! 123: ! 124: This routine also "knows" that an EOF indication on a stream is ! 125: "sticky" (i.e., you will keep getting EOF until you reposition the ! 126: stream). If your system doesn't work this way it is broken and you ! 127: should complain to the vendor. As a consequence of the sticky ! 128: EOF, this routine will never return any kind of EOF status when ! 129: there is data in "name" or "buf"). ! 130: */ ! 131: ! 132: ! 133: #define Getc(iob) getc(iob) ! 134: #define eom(c,iob) (msg_style != MS_DEFAULT && \ ! 135: (((c) == *msg_delim && m_Eom(c,iob)) ||\ ! 136: (eom_action && (*eom_action)(c)))) ! 137: ! 138: static char *matchc(); ! 139: static char *locc(); ! 140: ! 141: static char **pat_map; ! 142: ! 143: int msg_count = 0; /* disgusting hack for "inc" so it can ! 144: * know how many characters were stuffed ! 145: * in the buffer on the last call (see ! 146: * comments in uip/scansbr.c) */ ! 147: ! 148: int msg_style = MS_DEFAULT; ! 149: /* ! 150: * The "full" delimiter string for a packed maildrop consists ! 151: * of a newline followed by the actual delimiter. E.g., the ! 152: * full string for a Unix maildrop would be: "\n\nFrom ". ! 153: * "Fdelim" points to the start of the full string and is used ! 154: * in the BODY case of the main routine to search the buffer for ! 155: * a possible eom. Msg_delim points to the first character of ! 156: * the actual delim. string (i.e., fdelim+1). Edelim ! 157: * points to the 2nd character of actual delimiter string. It ! 158: * is used in m_Eom because the first character of the string ! 159: * has been read and matched before m_Eom is called. ! 160: */ ! 161: char *msg_delim = ""; ! 162: static char *fdelim; ! 163: static char *delimend; ! 164: static int fdelimlen; ! 165: static char *edelim; ! 166: static int edelimlen; ! 167: ! 168: static int (*eom_action) () = NULL; ! 169: ! 170: /* */ ! 171: ! 172: m_getfld (state, name, buf, bufsz, iob) ! 173: int state; ! 174: int bufsz; ! 175: char *name, ! 176: *buf; ! 177: register FILE *iob; ! 178: { ! 179: register char *cp; ! 180: register char *bp; ! 181: register int cnt; ! 182: register int c; ! 183: register int i; ! 184: register int j; ! 185: register char *ep; ! 186: register char *sp; ! 187: ! 188: if ((c = Getc(iob)) < 0) { ! 189: msg_count = 0; ! 190: *buf = 0; ! 191: return FILEEOF; ! 192: } ! 193: if (eom (c, iob)) { ! 194: if (! eom_action) { ! 195: /* flush null messages */ ! 196: while ((c = Getc(iob)) >= 0 && eom (c, iob)) ! 197: ; ! 198: if (c >= 0) ! 199: (void) ungetc(c, iob); ! 200: } ! 201: msg_count = 0; ! 202: *buf = 0; ! 203: return FILEEOF; ! 204: } ! 205: ! 206: switch (state) { ! 207: case FLDEOF: ! 208: case BODYEOF: ! 209: case FLD: ! 210: if (c == '\n' || c == '-') { ! 211: /* we hit the header/body separator */ ! 212: while (c != '\n' && (c = Getc(iob)) >= 0) ! 213: ; ! 214: ! 215: if (c < 0 || (c = Getc(iob)) < 0 || eom (c, iob)) { ! 216: if (! eom_action) { ! 217: /* flush null messages */ ! 218: while ((c = Getc(iob)) >= 0 && eom (c, iob)) ! 219: ; ! 220: if (c >= 0) ! 221: (void) ungetc(c, iob); ! 222: } ! 223: msg_count = 0; ! 224: *buf = 0; ! 225: return FILEEOF; ! 226: } ! 227: state = BODY; ! 228: goto body; ! 229: } ! 230: /* ! 231: * get the name of this component. take characters up ! 232: * to a ':', a newline or NAMESZ-1 characters, whichever ! 233: * comes first. ! 234: */ ! 235: cp = name; i = NAMESZ - 1; ! 236: for (;;) { ! 237: bp = sp = iob->_ptr - 1; ! 238: j = (cnt = iob->_cnt+1) < i ? cnt : i; ! 239: while ((c = *bp++) != ':' && c != '\n' && --j >= 0) ! 240: *cp++ = c; ! 241: ! 242: j = bp - sp; ! 243: if ((cnt -= j) <= 0) { ! 244: if (_filbuf(iob) == EOF) { ! 245: *cp = *buf = NULL; ! 246: advise (NULLCP, "eof encountered in field \"%s\"", ! 247: name); ! 248: return FMTERR; ! 249: } ! 250: } else { ! 251: iob->_ptr = bp + 1; ! 252: iob->_cnt = cnt - 1; ! 253: } ! 254: if (c == ':') ! 255: break; ! 256: ! 257: /* ! 258: * something went wrong. possibilities are: ! 259: * . hit a newline (error) ! 260: * . got more than namesz chars. (error) ! 261: * . hit the end of the buffer. (loop) ! 262: */ ! 263: if (c == '\n') { ! 264: *cp = *buf = NULL; ! 265: advise (NULLCP, "eol encountered in field \"%s\"", name); ! 266: state = FMTERR; ! 267: goto finish; ! 268: } ! 269: if ((i -= j) <= 0) { ! 270: *cp = *buf = NULL; ! 271: advise (NULLCP, "field name \"%s\" exceeds %d bytes", ! 272: name, NAMESZ - 1); ! 273: state = LENERR; ! 274: goto finish; ! 275: } ! 276: } ! 277: ! 278: while (isspace (*--cp) && cp >= name) ! 279: ; ! 280: *++cp = NULL; ! 281: /* fall through */ ! 282: ! 283: case FLDPLUS: ! 284: /* ! 285: * get (more of) the text of a field. take ! 286: * characters up to the end of this field (newline ! 287: * followed by non-blank) or bufsz-1 characters. ! 288: */ ! 289: cp = buf; i = bufsz-1; ! 290: for (;;) { ! 291: cnt = iob->_cnt++; bp = --iob->_ptr; ! 292: c = cnt < i ? cnt : i; ! 293: while (ep = locc( c, bp, '\n' )) { ! 294: /* ! 295: * if we hit the end of this field, return. ! 296: */ ! 297: if ((j = *++ep) != ' ' && j != '\t') { ! 298: j = ep - iob->_ptr; ! 299: (void) bcopy( iob->_ptr, cp, j); ! 300: iob->_ptr = ep; iob->_cnt -= j; ! 301: cp += j; ! 302: state = FLD; ! 303: goto finish; ! 304: } ! 305: c -= ep - bp; bp = ep; ! 306: } ! 307: /* ! 308: * end of input or dest buffer - copy what we've found. ! 309: */ ! 310: c += bp - iob->_ptr; ! 311: (void) bcopy( iob->_ptr, cp, c); ! 312: i -= c; cp += c; ! 313: if (i <= 0) { ! 314: /* the dest buffer is full */ ! 315: iob->_cnt -= c; iob->_ptr += c; ! 316: state = FLDPLUS; ! 317: break; ! 318: } ! 319: /* ! 320: * There's one character left in the input buffer. ! 321: * Copy it & fill the buffer. If the last char ! 322: * was a newline and the next char is not whitespace, ! 323: * this is the end of the field. Otherwise loop. ! 324: */ ! 325: --i; ! 326: *cp++ = j = *(iob->_ptr + c); ! 327: c = _filbuf(iob); ! 328: if (j == '\n' && c != ' ' && c != '\t') { ! 329: if (c != EOF) ! 330: --iob->_ptr, ++iob->_cnt; ! 331: state = FLD; ! 332: break; ! 333: } ! 334: } ! 335: break; ! 336: ! 337: case BODY: ! 338: body: ! 339: /* ! 340: * get the message body up to bufsz characters or the ! 341: * end of the message. Sleazy hack: if bufsz is negative ! 342: * we assume that we were called to copy directly into ! 343: * the output buffer and we don't add an eos. ! 344: */ ! 345: i = (bufsz < 0) ? -bufsz : bufsz-1; ! 346: bp = --iob->_ptr; cnt = ++iob->_cnt; ! 347: c = (cnt < i ? cnt : i); ! 348: if (msg_style != MS_DEFAULT && c > 1) { ! 349: /* ! 350: * packed maildrop - only take up to the (possible) ! 351: * start of the next message. This "matchc" should ! 352: * probably be a Boyer-Moore matcher for non-vaxen, ! 353: * particularly since we have the alignment table ! 354: * all built for the end-of-buffer test (next). ! 355: * But our vax timings indicate that the "matchc" ! 356: * instruction is 50% faster than a carefully coded ! 357: * B.M. matcher for most strings. (So much for elegant ! 358: * algorithms vs. brute force.) Since I (currently) ! 359: * run MH on a vax, we use the matchc instruction. --vj ! 360: */ ! 361: if (ep = matchc( fdelimlen, fdelim, c, bp ) ) ! 362: c = ep - bp + 1; ! 363: else { ! 364: /* ! 365: * There's no delim in the buffer but there may be ! 366: * a partial one at the end. If so, we want to leave ! 367: * it so the "eom" check on the next call picks it up. ! 368: * Use a modified Boyer-Moore matcher to make this ! 369: * check relatively cheap. The first "while" figures ! 370: * out what position in the pattern matches the last ! 371: * character in the buffer. The inner "while" matches ! 372: * the pattern against the buffer, backwards starting ! 373: * at that position. Note that unless the buffer ! 374: * ends with one of the characters in the pattern ! 375: * (excluding the first and last), we do only one test. ! 376: */ ! 377: sp = delimend; ! 378: ep = bp + c - 1; ! 379: while ((cp = pat_map[*ep]) < sp) { ! 380: ep = bp + c - 1; sp = cp; ! 381: while (*--ep == *--cp && cp > fdelim) ! 382: ; ! 383: if (cp == fdelim) { ! 384: if (*ep == *cp && ep > bp) ! 385: c = (ep - bp) + 1; ! 386: break; ! 387: } ! 388: } ! 389: } ! 390: } ! 391: (void) bcopy( bp, buf, c ); ! 392: iob->_cnt -= c; ! 393: iob->_ptr += c; ! 394: if (bufsz < 0) { ! 395: msg_count = c; ! 396: return (state); ! 397: } ! 398: cp = buf + c; ! 399: break; ! 400: ! 401: default: ! 402: adios (NULLCP, "m_getfld() called with bogus state of %d", state); ! 403: } ! 404: finish:; ! 405: *cp = NULL; ! 406: msg_count = cp - buf; ! 407: return (state); ! 408: } ! 409: ! 410: /* */ ! 411: ! 412: #ifdef RPATHS ! 413: static char unixbuf[BUFSIZ] = ""; ! 414: #endif RPATHS ! 415: ! 416: void m_unknown (iob) ! 417: register FILE *iob; ! 418: { ! 419: register int c; ! 420: register long pos; ! 421: char text[10]; ! 422: register char *cp; ! 423: ! 424: msg_style = MS_UNKNOWN; ! 425: ! 426: /* Figure out what the message delimitter string is for this ! 427: * maildrop. (This used to be part of m_Eom but I didn't like ! 428: * the idea of an "if" statement that could only succeed on the ! 429: * first call to m_Eom getting executed on each call, i.e., at ! 430: * every newline in the message). ! 431: * ! 432: * If the first line of the maildrop is a Unix "from" line, we say the ! 433: * style is UUCP and eat the rest of the line. Otherwise we say the style ! 434: * is MMDF & look for the delimiter string specified when MH was built ! 435: * (or from the mtstailor file). ! 436: */ ! 437: pos = ftell (iob); ! 438: if (fread (text, sizeof *text, 5, iob) == 5 ! 439: && strncmp (text, "From ", 5) == 0) { ! 440: msg_style = MS_UUCP; ! 441: fdelim = "\n\nFrom "; ! 442: #ifndef RPATHS ! 443: while ((c = getc (iob)) != '\n' && c >= 0) ! 444: ; ! 445: #else RPATHS ! 446: cp = unixbuf; ! 447: while ((c = getc (iob)) != '\n') ! 448: *cp++ = c; ! 449: *cp = NULL; ! 450: #endif RPATHS ! 451: } else { ! 452: /* not a Unix style maildrop */ ! 453: (void) fseek (iob, pos, 0); ! 454: if (mmdlm2 == NULLCP || *mmdlm2 == NULL) ! 455: mmdlm2 = "\001\001\001\001\n"; ! 456: fdelim = (char *)malloc((unsigned)strlen(mmdlm2)+2); ! 457: *fdelim = '\n'; ! 458: (void)strcpy(fdelim+1, mmdlm2); ! 459: msg_style = MS_MMDF; ! 460: } ! 461: fdelimlen = strlen(fdelim); ! 462: msg_delim = fdelim+1; ! 463: edelim = msg_delim+1; ! 464: edelimlen = fdelimlen-2; ! 465: delimend = msg_delim + edelimlen; ! 466: if (edelimlen <= 1) ! 467: adios (NULLCP, "maildrop delimiter must be at least 2 bytes"); ! 468: /* ! 469: * build a Boyer-Moore end-position map for the matcher in m_getfld. ! 470: * N.B. - we don't match just the first char (since it's the newline ! 471: * separator) or the last char (since the matchc would have found it ! 472: * if it was a real delim). ! 473: */ ! 474: pat_map = (char **) malloc( 256 * sizeof (char *)); ! 475: for (c = 256; c--; ) ! 476: pat_map[c] = delimend + 1; ! 477: ! 478: for (cp = fdelim + 1; cp < delimend; cp++ ) ! 479: pat_map[*cp] = cp; ! 480: ! 481: if (msg_style == MS_MMDF) { ! 482: /* flush extra msg hdrs */ ! 483: while ((c = Getc(iob)) >= 0 && eom (c, iob)) ! 484: ; ! 485: if (c >= 0) ! 486: (void) ungetc(c, iob); ! 487: } ! 488: } ! 489: ! 490: ! 491: void m_eomsbr (action) ! 492: int (*action) (); ! 493: { ! 494: if (eom_action = action) { ! 495: msg_style = MS_MSH; ! 496: *msg_delim = 0; ! 497: fdelimlen = 1; ! 498: delimend = fdelim; ! 499: } else { ! 500: msg_style = MS_MMDF; ! 501: msg_delim = fdelim + 1; ! 502: fdelimlen = strlen (fdelim); ! 503: delimend = msg_delim + edelimlen; ! 504: } ! 505: } ! 506: ! 507: /* */ ! 508: ! 509: /* test for msg delimiter string */ ! 510: ! 511: int m_Eom (c, iob) ! 512: register int c; ! 513: register FILE *iob; ! 514: { ! 515: register long pos = 0L; ! 516: register int i; ! 517: char text[10]; ! 518: #ifdef RPATHS ! 519: register char *cp; ! 520: #endif RPATHS ! 521: ! 522: pos = ftell (iob); ! 523: if ((i = fread (text, sizeof *text, edelimlen, iob)) != edelimlen ! 524: || strncmp (text, edelim, edelimlen)) { ! 525: if (i == 0 && msg_style == MS_UUCP) ! 526: /* the final newline in the (brain damaged) unix-format ! 527: * maildrop is part of the delimitter - delete it. ! 528: */ ! 529: return 1; ! 530: ! 531: (void) fseek (iob, pos, 0); ! 532: return 0; ! 533: } ! 534: ! 535: if (msg_style == MS_UUCP) { ! 536: #ifndef RPATHS ! 537: while ((c = getc (iob)) != '\n') ! 538: if (c < 0) ! 539: break; ! 540: #else RPATHS ! 541: cp = unixbuf; ! 542: while ((c = getc (iob)) != '\n' && c >= 0) ! 543: *cp++ = c; ! 544: *cp = NULL; ! 545: #endif RPATHS ! 546: } ! 547: ! 548: return 1; ! 549: } ! 550: ! 551: /* */ ! 552: ! 553: #ifdef RPATHS ! 554: char *unixline () { ! 555: register char *cp, ! 556: *dp, ! 557: *pp; ! 558: static char unixfrom[BUFSIZ]; ! 559: ! 560: pp = unixfrom; ! 561: if (cp = dp = index (unixbuf, ' ')) { ! 562: while (cp = index (cp + 1, 'r')) ! 563: if (strncmp (cp, "remote from ", 12) == 0) { ! 564: *cp = NULL; ! 565: (void) sprintf (pp, "%s!", cp + 12); ! 566: pp += strlen (pp); ! 567: break; ! 568: } ! 569: if (cp == NULL) ! 570: cp = unixbuf + strlen (unixbuf); ! 571: if ((cp -= 25) >= dp) ! 572: *cp = NULL; ! 573: } ! 574: ! 575: (void) sprintf (pp, "%s\n", unixbuf); ! 576: unixbuf[0] = NULL; ! 577: return unixfrom; ! 578: } ! 579: #endif RPATHS ! 580: ! 581: /* */ ! 582: ! 583: #if (vax && !lint) ! 584: asm(".align 1"); ! 585: asm("_matchc: .word 0"); ! 586: asm(" movq 4(ap),r0"); ! 587: asm(" movq 12(ap),r2"); ! 588: asm(" matchc r0,(r1),r2,(r3)"); ! 589: asm(" beql 1f"); ! 590: asm(" movl 4(ap),r3"); ! 591: asm("1: subl3 4(ap),r3,r0"); ! 592: asm(" ret"); ! 593: #else ! 594: static char * ! 595: matchc( patln, pat, strln, str ) ! 596: int patln; ! 597: char *pat; ! 598: int strln; ! 599: register char *str; ! 600: { ! 601: register char *es = str + strln - patln; ! 602: register char *sp; ! 603: register char *pp; ! 604: register char *ep = pat + patln; ! 605: register char pc = *pat++; ! 606: ! 607: for(;;) { ! 608: while (pc != *str++) ! 609: if (str > es) ! 610: return 0; ! 611: ! 612: sp = str; pp = pat; ! 613: while (pp < ep && *sp++ == *pp++) ! 614: ; ! 615: if (pp >= ep) ! 616: return (--str); ! 617: } ! 618: } ! 619: #endif ! 620: ! 621: /* */ ! 622: ! 623: /* ! 624: * Locate character "term" in the next "cnt" characters of "src". ! 625: * If found, return its address, otherwise return 0. ! 626: */ ! 627: #if (vax && !lint) ! 628: asm(".align 1"); ! 629: asm("_locc: .word 0"); ! 630: asm(" movq 4(ap),r0"); ! 631: asm(" locc 12(ap),r0,(r1)"); ! 632: asm(" beql 1f"); ! 633: asm(" movl r1,r0"); ! 634: asm("1: ret"); ! 635: #else ! 636: static char * ! 637: locc( cnt, src, term ) ! 638: register int cnt; ! 639: register char *src; ! 640: register char term; ! 641: { ! 642: while (*src++ != term && --cnt > 0); ! 643: ! 644: return (cnt > 0 ? --src : NULLCP); ! 645: } ! 646: #endif ! 647: ! 648: /* */ ! 649: ! 650: #if !defined (BSD42) && !defined (bcopy) ! 651: int bcmp (b1, b2, length) ! 652: register char *b1, ! 653: *b2; ! 654: register int length; ! 655: { ! 656: while (length-- > 0) ! 657: if (*b1++ != *b2++) ! 658: return 1; ! 659: ! 660: return 0; ! 661: } ! 662: ! 663: ! 664: bcopy (b1, b2, length) ! 665: register char *b1, ! 666: *b2; ! 667: register int length; ! 668: { ! 669: while (length-- > 0) ! 670: *b2++ = *b1++; ! 671: } ! 672: ! 673: ! 674: bzero (b, length) ! 675: register char *b; ! 676: register int length; ! 677: { ! 678: while (length-- > 0) ! 679: *b++ = NULL; ! 680: } ! 681: #endif not BSD42 or SYS5
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.