![[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] / 43BSDReno / contrib / mh / sbr|
Return to m_getfld.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / 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 unsigned char *matchc(); ! 139: static unsigned char *locc(); ! 140: ! 141: static unsigned 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 unsigned char *fdelim; ! 163: static unsigned char *delimend; ! 164: static int fdelimlen; ! 165: static unsigned 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: unsigned char *name, *buf; ! 176: register FILE *iob; ! 177: { ! 178: register unsigned char *cp; ! 179: register unsigned char *bp; ! 180: register int cnt; ! 181: register int c; ! 182: register int i; ! 183: register int j; ! 184: register unsigned char *ep; ! 185: register unsigned char *sp; ! 186: ! 187: if ((c = Getc(iob)) < 0) { ! 188: msg_count = 0; ! 189: *buf = 0; ! 190: return FILEEOF; ! 191: } ! 192: if (eom (c, iob)) { ! 193: if (! eom_action) { ! 194: /* flush null messages */ ! 195: while ((c = Getc(iob)) >= 0 && eom (c, iob)) ! 196: ; ! 197: if (c >= 0) ! 198: (void) ungetc(c, iob); ! 199: } ! 200: msg_count = 0; ! 201: *buf = 0; ! 202: return FILEEOF; ! 203: } ! 204: ! 205: switch (state) { ! 206: case FLDEOF: ! 207: case BODYEOF: ! 208: case FLD: ! 209: if (c == '\n' || c == '-') { ! 210: /* we hit the header/body separator */ ! 211: while (c != '\n' && (c = Getc(iob)) >= 0) ! 212: ; ! 213: ! 214: if (c < 0 || (c = Getc(iob)) < 0 || eom (c, iob)) { ! 215: if (! eom_action) { ! 216: /* flush null messages */ ! 217: while ((c = Getc(iob)) >= 0 && eom (c, iob)) ! 218: ; ! 219: if (c >= 0) ! 220: (void) ungetc(c, iob); ! 221: } ! 222: msg_count = 0; ! 223: *buf = 0; ! 224: return FILEEOF; ! 225: } ! 226: state = BODY; ! 227: goto body; ! 228: } ! 229: /* ! 230: * get the name of this component. take characters up ! 231: * to a ':', a newline or NAMESZ-1 characters, whichever ! 232: * comes first. ! 233: */ ! 234: cp = name; i = NAMESZ - 1; ! 235: for (;;) { ! 236: bp = sp = (unsigned char *) iob->_ptr - 1; ! 237: j = (cnt = iob->_cnt+1) < i ? cnt : i; ! 238: while ((c = *bp++) != ':' && c != '\n' && --j >= 0) ! 239: *cp++ = c; ! 240: ! 241: j = bp - sp; ! 242: if ((cnt -= j) <= 0) { ! 243: if (_filbuf(iob) == EOF) { ! 244: *cp = *buf = NULL; ! 245: advise (NULLCP, "eof encountered in field \"%s\"", ! 246: name); ! 247: return FMTERR; ! 248: } ! 249: } else { ! 250: iob->_ptr = (char *) bp + 1; ! 251: iob->_cnt = cnt - 1; ! 252: } ! 253: if (c == ':') ! 254: break; ! 255: ! 256: /* ! 257: * something went wrong. possibilities are: ! 258: * . hit a newline (error) ! 259: * . got more than namesz chars. (error) ! 260: * . hit the end of the buffer. (loop) ! 261: */ ! 262: if (c == '\n') { ! 263: *cp = *buf = NULL; ! 264: advise (NULLCP, "eol encountered in field \"%s\"", name); ! 265: state = FMTERR; ! 266: goto finish; ! 267: } ! 268: if ((i -= j) <= 0) { ! 269: *cp = *buf = NULL; ! 270: advise (NULLCP, "field name \"%s\" exceeds %d bytes", ! 271: name, NAMESZ - 1); ! 272: state = LENERR; ! 273: goto finish; ! 274: } ! 275: } ! 276: ! 277: while (isspace (*--cp) && cp >= name) ! 278: ; ! 279: *++cp = NULL; ! 280: /* fall through */ ! 281: ! 282: case FLDPLUS: ! 283: /* ! 284: * get (more of) the text of a field. take ! 285: * characters up to the end of this field (newline ! 286: * followed by non-blank) or bufsz-1 characters. ! 287: */ ! 288: cp = buf; i = bufsz-1; ! 289: for (;;) { ! 290: cnt = iob->_cnt++; bp = (unsigned char *) --iob->_ptr; ! 291: c = cnt < i ? cnt : i; ! 292: while (ep = locc( c, bp, '\n' )) { ! 293: /* ! 294: * if we hit the end of this field, return. ! 295: */ ! 296: if ((j = *++ep) != ' ' && j != '\t') { ! 297: j = ep - (unsigned char *) iob->_ptr; ! 298: (void) bcopy( iob->_ptr, cp, j); ! 299: iob->_ptr = (char *) ep; iob->_cnt -= j; ! 300: cp += j; ! 301: state = FLD; ! 302: goto finish; ! 303: } ! 304: c -= ep - bp; bp = ep; ! 305: } ! 306: /* ! 307: * end of input or dest buffer - copy what we've found. ! 308: */ ! 309: c += bp - (unsigned char *) iob->_ptr; ! 310: (void) bcopy( iob->_ptr, cp, c); ! 311: i -= c; cp += c; ! 312: if (i <= 0) { ! 313: /* the dest buffer is full */ ! 314: iob->_cnt -= c; iob->_ptr += c; ! 315: state = FLDPLUS; ! 316: break; ! 317: } ! 318: /* ! 319: * There's one character left in the input buffer. ! 320: * Copy it & fill the buffer. If the last char ! 321: * was a newline and the next char is not whitespace, ! 322: * this is the end of the field. Otherwise loop. ! 323: */ ! 324: --i; ! 325: *cp++ = j = *(iob->_ptr + c); ! 326: c = _filbuf(iob); ! 327: if (j == '\n' && c != ' ' && c != '\t') { ! 328: if (c != EOF) ! 329: --iob->_ptr, ++iob->_cnt; ! 330: state = FLD; ! 331: break; ! 332: } ! 333: } ! 334: break; ! 335: ! 336: case BODY: ! 337: body: ! 338: /* ! 339: * get the message body up to bufsz characters or the ! 340: * end of the message. Sleazy hack: if bufsz is negative ! 341: * we assume that we were called to copy directly into ! 342: * the output buffer and we don't add an eos. ! 343: */ ! 344: i = (bufsz < 0) ? -bufsz : bufsz-1; ! 345: bp = (unsigned char *) --iob->_ptr; cnt = ++iob->_cnt; ! 346: c = (cnt < i ? cnt : i); ! 347: if (msg_style != MS_DEFAULT && c > 1) { ! 348: /* ! 349: * packed maildrop - only take up to the (possible) ! 350: * start of the next message. This "matchc" should ! 351: * probably be a Boyer-Moore matcher for non-vaxen, ! 352: * particularly since we have the alignment table ! 353: * all built for the end-of-buffer test (next). ! 354: * But our vax timings indicate that the "matchc" ! 355: * instruction is 50% faster than a carefully coded ! 356: * B.M. matcher for most strings. (So much for elegant ! 357: * algorithms vs. brute force.) Since I (currently) ! 358: * run MH on a vax, we use the matchc instruction. --vj ! 359: */ ! 360: if (ep = matchc( fdelimlen, fdelim, c, bp ) ) ! 361: c = ep - bp + 1; ! 362: else { ! 363: /* ! 364: * There's no delim in the buffer but there may be ! 365: * a partial one at the end. If so, we want to leave ! 366: * it so the "eom" check on the next call picks it up. ! 367: * Use a modified Boyer-Moore matcher to make this ! 368: * check relatively cheap. The first "if" figures ! 369: * out what position in the pattern matches the last ! 370: * character in the buffer. The inner "while" matches ! 371: * the pattern against the buffer, backwards starting ! 372: * at that position. Note that unless the buffer ! 373: * ends with one of the characters in the pattern ! 374: * (excluding the first and last), we do only one test. ! 375: */ ! 376: ep = bp + c - 1; ! 377: if (sp = pat_map[*ep]) { ! 378: do { ! 379: cp = sp; ! 380: while (*--ep == *--cp) ! 381: ; ! 382: if (cp < fdelim) { ! 383: if (ep >= bp) ! 384: /* ! 385: * ep < bp means that all the buffer ! 386: * contains is a prefix of delim. ! 387: * If this prefix is really a delim, the ! 388: * m_eom call at entry should have found ! 389: * it. Thus it's not a delim and we can ! 390: * take all of it. ! 391: */ ! 392: c = (ep - bp) + 2; ! 393: break; ! 394: } ! 395: /* try matching one less char of delim string */ ! 396: ep = bp + c - 1; ! 397: } while (--sp > fdelim); ! 398: } ! 399: } ! 400: } ! 401: (void) bcopy( bp, buf, c ); ! 402: iob->_cnt -= c; ! 403: iob->_ptr += c; ! 404: if (bufsz < 0) { ! 405: msg_count = c; ! 406: return (state); ! 407: } ! 408: cp = buf + c; ! 409: break; ! 410: ! 411: default: ! 412: adios (NULLCP, "m_getfld() called with bogus state of %d", state); ! 413: } ! 414: finish:; ! 415: *cp = NULL; ! 416: msg_count = cp - buf; ! 417: return (state); ! 418: } ! 419: ! 420: /* */ ! 421: ! 422: #ifdef RPATHS ! 423: static char unixbuf[BUFSIZ] = ""; ! 424: #endif RPATHS ! 425: ! 426: void ! 427: m_unknown(iob) ! 428: register FILE *iob; ! 429: { ! 430: register int c; ! 431: register long pos; ! 432: char text[10]; ! 433: register char *cp; ! 434: register char *delimstr; ! 435: ! 436: msg_style = MS_UNKNOWN; ! 437: ! 438: /* Figure out what the message delimitter string is for this ! 439: * maildrop. (This used to be part of m_Eom but I didn't like ! 440: * the idea of an "if" statement that could only succeed on the ! 441: * first call to m_Eom getting executed on each call, i.e., at ! 442: * every newline in the message). ! 443: * ! 444: * If the first line of the maildrop is a Unix "from" line, we say the ! 445: * style is UUCP and eat the rest of the line. Otherwise we say the style ! 446: * is MMDF & look for the delimiter string specified when MH was built ! 447: * (or from the mtstailor file). ! 448: */ ! 449: pos = ftell (iob); ! 450: if (fread (text, sizeof *text, 5, iob) == 5 ! 451: && strncmp (text, "From ", 5) == 0) { ! 452: msg_style = MS_UUCP; ! 453: delimstr = "\nFrom "; ! 454: #ifndef RPATHS ! 455: while ((c = getc (iob)) != '\n' && c >= 0) ! 456: ; ! 457: #else RPATHS ! 458: cp = unixbuf; ! 459: while ((c = getc (iob)) != '\n') ! 460: *cp++ = c; ! 461: *cp = NULL; ! 462: #endif RPATHS ! 463: } else { ! 464: /* not a Unix style maildrop */ ! 465: (void) fseek (iob, pos, 0); ! 466: if (mmdlm2 == NULLCP || *mmdlm2 == NULL) ! 467: mmdlm2 = "\001\001\001\001\n"; ! 468: delimstr = mmdlm2; ! 469: msg_style = MS_MMDF; ! 470: } ! 471: c = strlen (delimstr); ! 472: fdelim = (unsigned char *)malloc((unsigned)c + 3); ! 473: *fdelim++ = '\0'; ! 474: *fdelim = '\n'; ! 475: msg_delim = (char *)fdelim+1; ! 476: edelim = (unsigned char *)msg_delim+1; ! 477: fdelimlen = c + 1; ! 478: edelimlen = c - 1; ! 479: (void)strcpy(msg_delim, delimstr); ! 480: delimend = (unsigned char *)msg_delim + edelimlen; ! 481: if (edelimlen <= 1) ! 482: adios (NULLCP, "maildrop delimiter must be at least 2 bytes"); ! 483: /* ! 484: * build a Boyer-Moore end-position map for the matcher in m_getfld. ! 485: * N.B. - we don't match just the first char (since it's the newline ! 486: * separator) or the last char (since the matchc would have found it ! 487: * if it was a real delim). ! 488: */ ! 489: pat_map = (unsigned char **) calloc (256, sizeof (unsigned char *)); ! 490: ! 491: for (cp = (char *)fdelim + 1; cp < (char *)delimend; cp++ ) ! 492: pat_map[*cp] = (unsigned char *)cp; ! 493: ! 494: if (msg_style == MS_MMDF) { ! 495: /* flush extra msg hdrs */ ! 496: while ((c = Getc(iob)) >= 0 && eom (c, iob)) ! 497: ; ! 498: if (c >= 0) ! 499: (void) ungetc(c, iob); ! 500: } ! 501: } ! 502: ! 503: void ! 504: m_eomsbr(action) ! 505: int (*action)(); ! 506: { ! 507: if (eom_action = action) { ! 508: msg_style = MS_MSH; ! 509: *msg_delim = 0; ! 510: fdelimlen = 1; ! 511: delimend = fdelim; ! 512: } else { ! 513: msg_style = MS_MMDF; ! 514: msg_delim = (char *)fdelim + 1; ! 515: fdelimlen = strlen(fdelim); ! 516: delimend = (unsigned char *)(msg_delim + edelimlen); ! 517: } ! 518: } ! 519: ! 520: /* */ ! 521: ! 522: /* test for msg delimiter string */ ! 523: ! 524: int ! 525: m_Eom(c, iob) ! 526: register int c; ! 527: register FILE *iob; ! 528: { ! 529: register long pos = 0L; ! 530: register int i; ! 531: char text[10]; ! 532: #ifdef RPATHS ! 533: register char *cp; ! 534: #endif RPATHS ! 535: ! 536: pos = ftell (iob); ! 537: if ((i = fread (text, sizeof *text, edelimlen, iob)) != edelimlen ! 538: || strncmp (text, edelim, edelimlen)) { ! 539: if (i == 0 && msg_style == MS_UUCP) ! 540: /* the final newline in the (brain damaged) unix-format ! 541: * maildrop is part of the delimitter - delete it. ! 542: */ ! 543: return 1; ! 544: ! 545: (void) fseek (iob, pos, 0); ! 546: return 0; ! 547: } ! 548: ! 549: if (msg_style == MS_UUCP) { ! 550: #ifndef RPATHS ! 551: while ((c = getc (iob)) != '\n') ! 552: if (c < 0) ! 553: break; ! 554: #else RPATHS ! 555: cp = unixbuf; ! 556: while ((c = getc (iob)) != '\n' && c >= 0) ! 557: *cp++ = c; ! 558: *cp = NULL; ! 559: #endif RPATHS ! 560: } ! 561: ! 562: return 1; ! 563: } ! 564: ! 565: /* */ ! 566: ! 567: #ifdef RPATHS ! 568: char * ! 569: unixline() ! 570: { ! 571: register char *cp, ! 572: *dp, ! 573: *pp; ! 574: static char unixfrom[BUFSIZ]; ! 575: ! 576: pp = unixfrom; ! 577: if (cp = dp = index (unixbuf, ' ')) { ! 578: while (cp = index (cp + 1, 'r')) ! 579: if (strncmp (cp, "remote from ", 12) == 0) { ! 580: *cp = NULL; ! 581: (void) sprintf (pp, "%s!", cp + 12); ! 582: pp += strlen (pp); ! 583: break; ! 584: } ! 585: if (cp == NULL) ! 586: cp = unixbuf + strlen (unixbuf); ! 587: if ((cp -= 25) >= dp) ! 588: *cp = NULL; ! 589: } ! 590: ! 591: (void) sprintf (pp, "%s\n", unixbuf); ! 592: unixbuf[0] = NULL; ! 593: return unixfrom; ! 594: } ! 595: #endif RPATHS ! 596: ! 597: /* */ ! 598: ! 599: #if (vax && !lint) ! 600: asm(".align 1"); ! 601: asm("_matchc: .word 0"); ! 602: asm(" movq 4(ap),r0"); ! 603: asm(" movq 12(ap),r2"); ! 604: asm(" matchc r0,(r1),r2,(r3)"); ! 605: asm(" beql 1f"); ! 606: asm(" movl 4(ap),r3"); ! 607: asm("1: subl3 4(ap),r3,r0"); ! 608: asm(" ret"); ! 609: #else ! 610: static unsigned char * ! 611: matchc( patln, pat, strln, str ) ! 612: int patln; ! 613: char *pat; ! 614: int strln; ! 615: register char *str; ! 616: { ! 617: register char *es = str + strln - patln; ! 618: register char *sp; ! 619: register char *pp; ! 620: register char *ep = pat + patln; ! 621: register char pc = *pat++; ! 622: ! 623: for(;;) { ! 624: while (pc != *str++) ! 625: if (str > es) ! 626: return 0; ! 627: ! 628: sp = str; pp = pat; ! 629: while (pp < ep && *sp++ == *pp++) ! 630: ; ! 631: if (pp >= ep) ! 632: return ((unsigned char *)--str); ! 633: } ! 634: } ! 635: #endif ! 636: ! 637: /* */ ! 638: ! 639: /* ! 640: * Locate character "term" in the next "cnt" characters of "src". ! 641: * If found, return its address, otherwise return 0. ! 642: */ ! 643: #if (vax && !lint) ! 644: asm(".align 1"); ! 645: asm("_locc: .word 0"); ! 646: asm(" movq 4(ap),r0"); ! 647: asm(" locc 12(ap),r0,(r1)"); ! 648: asm(" beql 1f"); ! 649: asm(" movl r1,r0"); ! 650: asm("1: ret"); ! 651: #else ! 652: static unsigned char * ! 653: locc( cnt, src, term ) ! 654: register int cnt; ! 655: register unsigned char *src; ! 656: register unsigned char term; ! 657: { ! 658: while (*src++ != term && --cnt > 0); ! 659: ! 660: return (cnt > 0 ? --src : (unsigned char *)0); ! 661: } ! 662: #endif ! 663: ! 664: /* */ ! 665: ! 666: #if !defined (BSD42) && !defined (bcopy) ! 667: int ! 668: bcmp(b1, b2, length) ! 669: register char *b1, *b2; ! 670: register int length; ! 671: { ! 672: while (length-- > 0) ! 673: if (*b1++ != *b2++) ! 674: return 1; ! 675: ! 676: return 0; ! 677: } ! 678: ! 679: ! 680: bcopy(b1, b2, length) ! 681: register char *b1, *b2; ! 682: register int length; ! 683: { ! 684: while (length-- > 0) ! 685: *b2++ = *b1++; ! 686: } ! 687: ! 688: ! 689: bzero(b, length) ! 690: register char *b; ! 691: register int length; ! 692: { ! 693: while (length-- > 0) ! 694: *b++ = NULL; ! 695: } ! 696: #endif not BSD42 or SYS5
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.